generic-atomics 0.1.0

Generic Atomic types for types that implement num-primitive traits
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
127
128
129
130
131
132
133
134
135
136
137

use crate::{
    atomic_float_wrapper::{
        Abs, Neg, UseUpdateToAdd, UseUpdateToMax, UseUpdateToMin, UseUpdateToSub,
    },
    AtomicNumber, IntoAtomicNumber,
};
use atomic_traits::{fetch::Update, AsPtr, Atomic, Bitwise};
use core::sync::atomic::Ordering::{self};
use num_primitive::PrimitiveFloat;
use num_traits::FromPrimitive;

pub trait AtomicFloat<F>:
    Atomic<Type = F>
    + Bitwise
    + AsPtr
    + Update<Type = F>
    + Abs<Type = F>
    + Neg<Type = F>
    + UseUpdateToAdd<Type = F>
    + UseUpdateToSub<Type = F>
    + UseUpdateToMin<Type = F>
    + UseUpdateToMax<Type = F>
    + Send
    + Sync
where
    F: PrimitiveFloat,
{
}

impl<AF, F> AtomicFloat<F> for AF
where
    AF: Atomic<Type = F>
        + Bitwise
        + AsPtr
        + Update<Type = F>
        + Abs<Type = F>
        + Neg<Type = F>
        + UseUpdateToAdd<Type = F>
        + UseUpdateToSub<Type = F>
        + UseUpdateToMin<Type = F>
        + UseUpdateToMax<Type = F>
        + Send
        + Sync,
    F: PrimitiveFloat,
{
}

pub trait IntoAtomicFloat: IntoAtomicNumber<AN = Self::AF> + PrimitiveFloat {
    type AF: AtomicFloat<Self>;
    fn into_atomic_float(self) -> impl AtomicFloat<Self>;
}

impl<T, A> IntoAtomicFloat for T
where
    T: IntoAtomicNumber<AN = A> + PrimitiveFloat + FromPrimitive,
    A: AtomicFloat<Self>,
{
    type AF = T::AN;

    fn into_atomic_float(self) -> impl AtomicFloat<Self> {
        Self::AF::new(self)
    }
}

pub trait PrimitiveAtomicFloat: PrimitiveFloat + IntoAtomicFloat {}
impl<T> PrimitiveAtomicFloat for T where T: PrimitiveFloat + IntoAtomicFloat {}

impl<T> Abs for AtomicNumber<T>
where
    T: PrimitiveAtomicFloat + FromPrimitive,
{
    type Type = T;

    #[inline(always)]
    fn fetch_abs(&self, order: Ordering) -> Self::Type {
        self.atomic.fetch_abs(order)
    }
}

impl<T> Neg for AtomicNumber<T>
where
    T: PrimitiveAtomicFloat + FromPrimitive,
{
    type Type = T;

    #[inline(always)]
    fn fetch_neg(&self, order: Ordering) -> Self::Type {
        self.atomic.fetch_neg(order)
    }
}
impl<T> UseUpdateToAdd for AtomicNumber<T>
where
    T: PrimitiveAtomicFloat + FromPrimitive,
{
    type Type = T;

    #[inline(always)]
    fn fetch_add_via_update(&self, val: Self::Type, order: Ordering) -> Self::Type {
        self.atomic.fetch_add_via_update(val, order)
    }
}

impl<T> UseUpdateToSub for AtomicNumber<T>
where
    T: PrimitiveAtomicFloat + FromPrimitive,
{
    type Type = T;

    #[inline(always)]
    fn fetch_sub_via_update(&self, val: Self::Type, order: Ordering) -> Self::Type {
        self.atomic.fetch_sub_via_update(val, order)
    }
}

impl<T> UseUpdateToMin for AtomicNumber<T>
where
    T: PrimitiveAtomicFloat + FromPrimitive,
{
    type Type = T;

    #[inline(always)]
    fn fetch_min_via_update(&self, val: Self::Type, order: Ordering) -> Self::Type {
        self.atomic.fetch_min_via_update(val, order)
    }
}

impl<T> UseUpdateToMax for AtomicNumber<T>
where
    T: PrimitiveAtomicFloat + FromPrimitive,
{
    type Type = T;

    #[inline]
    fn fetch_max_via_update(&self, val: Self::Type, order: Ordering) -> T {
        self.atomic.fetch_max_via_update(val, order)
    }
}