use super::Atomic;
use std::sync::atomic::Ordering;
#[derive(Debug)]
pub struct AtomicBool(Atomic<bool>);
impl AtomicBool {
#[track_caller]
pub fn new(v: bool) -> AtomicBool {
AtomicBool(Atomic::new(v, location!()))
}
#[track_caller]
pub unsafe fn unsync_load(&self) -> bool {
self.0.unsync_load()
}
#[track_caller]
pub fn load(&self, order: Ordering) -> bool {
self.0.load(order)
}
#[track_caller]
pub fn store(&self, val: bool, order: Ordering) {
self.0.store(val, order)
}
#[track_caller]
pub fn swap(&self, val: bool, order: Ordering) -> bool {
self.0.swap(val, order)
}
#[track_caller]
pub fn compare_and_swap(&self, current: bool, new: bool, order: Ordering) -> bool {
self.0.compare_and_swap(current, new, order)
}
#[track_caller]
pub fn compare_exchange(
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering,
) -> Result<bool, bool> {
self.0.compare_exchange(current, new, success, failure)
}
#[track_caller]
pub fn compare_exchange_weak(
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering,
) -> Result<bool, bool> {
self.compare_exchange(current, new, success, failure)
}
#[track_caller]
pub fn fetch_and(&self, val: bool, order: Ordering) -> bool {
self.0.rmw(|v| v & val, order)
}
#[track_caller]
pub fn fetch_nand(&self, val: bool, order: Ordering) -> bool {
self.0.rmw(|v| !(v & val), order)
}
#[track_caller]
pub fn fetch_or(&self, val: bool, order: Ordering) -> bool {
self.0.rmw(|v| v | val, order)
}
#[track_caller]
pub fn fetch_xor(&self, val: bool, order: Ordering) -> bool {
self.0.rmw(|v| v ^ val, order)
}
#[track_caller]
pub fn fetch_update<F>(
&self,
set_order: Ordering,
fetch_order: Ordering,
f: F,
) -> Result<bool, bool>
where
F: FnMut(bool) -> Option<bool>,
{
self.0.fetch_update(set_order, fetch_order, f)
}
}
impl Default for AtomicBool {
fn default() -> AtomicBool {
AtomicBool::new(Default::default())
}
}
impl From<bool> for AtomicBool {
fn from(b: bool) -> Self {
Self::new(b)
}
}