qubit-atomic 0.14.0

User-friendly atomic operations wrapper providing JDK-like atomic API
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

// =============================================================================
//    Copyright (c) 2025 - 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================

//! Macro for implementing hidden integer marker operations.

/// Implements hidden integer marker operations for a supported primitive type.
macro_rules! impl_atomic_integer_value {
    ($value_type:ty, $primitive_type:ty, $inner_type:ty) => {
        impl_atomic_value!($value_type, $primitive_type, $inner_type);

        impl AtomicIntegerValue for $value_type {
            #[inline]
            fn fetch_inc(primitive: &Self::Primitive) -> Self {
                primitive.fetch_inc()
            }

            #[inline]
            fn fetch_inc_with_ordering(
                primitive: &Self::Primitive,
                ordering: Ordering,
            ) -> Self {
                primitive.fetch_inc_with_ordering(ordering)
            }

            #[inline]
            fn fetch_dec(primitive: &Self::Primitive) -> Self {
                primitive.fetch_dec()
            }

            #[inline]
            fn fetch_dec_with_ordering(
                primitive: &Self::Primitive,
                ordering: Ordering,
            ) -> Self {
                primitive.fetch_dec_with_ordering(ordering)
            }

            #[inline]
            fn fetch_add_with_ordering(
                primitive: &Self::Primitive,
                value: Self,
                ordering: Ordering,
            ) -> Self {
                primitive.fetch_add_with_ordering(value, ordering)
            }

            #[inline]
            fn fetch_sub_with_ordering(
                primitive: &Self::Primitive,
                value: Self,
                ordering: Ordering,
            ) -> Self {
                primitive.fetch_sub_with_ordering(value, ordering)
            }

            #[inline]
            fn fetch_and(primitive: &Self::Primitive, value: Self) -> Self {
                primitive.fetch_and(value)
            }

            #[inline]
            fn fetch_or(primitive: &Self::Primitive, value: Self) -> Self {
                primitive.fetch_or(value)
            }

            #[inline]
            fn fetch_xor(primitive: &Self::Primitive, value: Self) -> Self {
                primitive.fetch_xor(value)
            }

            #[inline]
            fn fetch_not(primitive: &Self::Primitive) -> Self {
                primitive.fetch_not()
            }

            #[inline]
            fn fetch_accumulate<F>(
                primitive: &Self::Primitive,
                value: Self,
                f: F,
            ) -> Self
            where
                F: FnMut(Self, Self) -> Self,
            {
                primitive.fetch_accumulate(value, f)
            }

            #[inline]
            fn accumulate_and_get<F>(
                primitive: &Self::Primitive,
                value: Self,
                f: F,
            ) -> Self
            where
                F: FnMut(Self, Self) -> Self,
            {
                primitive.accumulate_and_get(value, f)
            }

            #[inline]
            fn fetch_max(primitive: &Self::Primitive, value: Self) -> Self {
                primitive.fetch_max(value)
            }

            #[inline]
            fn fetch_min(primitive: &Self::Primitive, value: Self) -> Self {
                primitive.fetch_min(value)
            }
        }
    };
}