isnt 0.2.0

Inverted versions of boolean-valued stdlib functions
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

// This file was generated

mod atomic_bool_private { pub trait Sealed { } }

/// Extension for [`AtomicBool`](std::sync::atomic::AtomicBool)
pub trait IsntAtomicBoolExt: atomic_bool_private::Sealed {
    /// The negation of [`into_inner`](std::sync::atomic::AtomicBool::into_inner)
    #[must_use]
    fn not_into_inner(self) -> bool;
    /// The negation of [`load`](std::sync::atomic::AtomicBool::load)
    #[must_use]
    fn not_load(&self, order: std::sync::atomic::Ordering) -> bool;
    /// The negation of [`swap`](std::sync::atomic::AtomicBool::swap)
    #[must_use]
    fn not_swap(&self, val: bool, order: std::sync::atomic::Ordering) -> bool;
    /// The negation of [`fetch_and`](std::sync::atomic::AtomicBool::fetch_and)
    #[must_use]
    fn not_fetch_and(&self, val: bool, order: std::sync::atomic::Ordering) -> bool;
    /// The negation of [`fetch_nand`](std::sync::atomic::AtomicBool::fetch_nand)
    #[must_use]
    fn not_fetch_nand(&self, val: bool, order: std::sync::atomic::Ordering) -> bool;
    /// The negation of [`fetch_xor`](std::sync::atomic::AtomicBool::fetch_xor)
    #[must_use]
    fn not_fetch_xor(&self, val: bool, order: std::sync::atomic::Ordering) -> bool;
    /// The negation of [`fetch_not`](std::sync::atomic::AtomicBool::fetch_not)
    #[must_use]
    fn not_fetch_not(&self, order: std::sync::atomic::Ordering) -> bool;
}

impl atomic_bool_private::Sealed for std::sync::atomic::AtomicBool { }

impl IsntAtomicBoolExt for std::sync::atomic::AtomicBool {
    #[inline]
    fn not_into_inner(self) -> bool {
        !self.into_inner()
    }

    #[inline]
    fn not_load(&self, order: std::sync::atomic::Ordering) -> bool {
        !self.load(order)
    }

    #[inline]
    fn not_swap(&self, val: bool, order: std::sync::atomic::Ordering) -> bool {
        !self.swap(val, order)
    }

    #[inline]
    fn not_fetch_and(&self, val: bool, order: std::sync::atomic::Ordering) -> bool {
        !self.fetch_and(val, order)
    }

    #[inline]
    fn not_fetch_nand(&self, val: bool, order: std::sync::atomic::Ordering) -> bool {
        !self.fetch_nand(val, order)
    }

    #[inline]
    fn not_fetch_xor(&self, val: bool, order: std::sync::atomic::Ordering) -> bool {
        !self.fetch_xor(val, order)
    }

    #[inline]
    fn not_fetch_not(&self, order: std::sync::atomic::Ordering) -> bool {
        !self.fetch_not(order)
    }
}