/// Creates an `AtomicBool` initialized to `false`.

#[inline]

fn default() -> Self {

Self::new(false)

}

/// Creates a null `AtomicPtr<T>`.

fn default() -> AtomicPtr<T> {

AtomicPtr::new(crate::ptr::null_mut())

}

/// No ordering constraints, only atomic operations.

///

/// Corresponds to [`memory_order_relaxed`] in C++20.

///

/// [`memory_order_relaxed`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Relaxed_ordering

#[stable(feature = "rust1", since = "1.0.0")]

Relaxed,

/// When coupled with a store, all previous operations become ordered

/// before any load of this value with [`Acquire`] (or stronger) ordering.

/// In particular, all previous writes become visible to all threads

/// that perform an [`Acquire`] (or stronger) load of this value.

///

/// Notice that using this ordering for an operation that combines loads

/// and stores leads to a [`Relaxed`] load operation!

///

/// This ordering is only applicable for operations that can perform a store.

///

/// Corresponds to [`memory_order_release`] in C++20.

///

/// [`memory_order_release`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release-Acquire_ordering

#[stable(feature = "rust1", since = "1.0.0")]

Release,

/// When coupled with a load, if the loaded value was written by a store operation with

/// [`Release`] (or stronger) ordering, then all subsequent operations

/// become ordered after that store. In particular, all subsequent loads will see data

/// written before the store.

///

/// Notice that using this ordering for an operation that combines loads

/// and stores leads to a [`Relaxed`] store operation!

///

/// This ordering is only applicable for operations that can perform a load.

///

/// Corresponds to [`memory_order_acquire`] in C++20.

///

/// [`memory_order_acquire`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release-Acquire_ordering

#[stable(feature = "rust1", since = "1.0.0")]

Acquire,

/// Has the effects of both [`Acquire`] and [`Release`] together:

/// For loads it uses [`Acquire`] ordering. For stores it uses the [`Release`] ordering.

///

/// Notice that in the case of `compare_and_swap`, it is possible that the operation ends up

/// not performing any store and hence it has just [`Acquire`] ordering. However,

/// `AcqRel` will never perform [`Relaxed`] accesses.

///

/// This ordering is only applicable for operations that combine both loads and stores.

///

/// Corresponds to [`memory_order_acq_rel`] in C++20.

///

/// [`memory_order_acq_rel`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Release-Acquire_ordering

#[stable(feature = "rust1", since = "1.0.0")]

AcqRel,

/// Like [`Acquire`]/[`Release`]/[`AcqRel`] (for load, store, and load-with-store

/// operations, respectively) with the additional guarantee that all threads see all

/// sequentially consistent operations in the same order.

///

/// Corresponds to [`memory_order_seq_cst`] in C++20.

///

/// [`memory_order_seq_cst`]: https://en.cppreference.com/w/cpp/atomic/memory_order#Sequentially-consistent_ordering

#[stable(feature = "rust1", since = "1.0.0")]

SeqCst,

/// Creates a new `AtomicBool`.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::AtomicBool;

///

/// let atomic_true = AtomicBool::new(true);

/// let atomic_false = AtomicBool::new(false);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

#[rustc_const_stable(feature = "const_atomic_new", since = "1.24.0")]

#[must_use]

pub const fn new(v: bool) -> AtomicBool {

AtomicBool { v: UnsafeCell::new(v as u8) }

}

/// Returns a mutable reference to the underlying [`bool`].

///

/// This is safe because the mutable reference guarantees that no other threads are

/// concurrently accessing the atomic data.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let mut some_bool = AtomicBool::new(true);

/// assert_eq!(*some_bool.get_mut(), true);

/// *some_bool.get_mut() = false;

/// assert_eq!(some_bool.load(Ordering::SeqCst), false);

/// ```

#[inline]

#[stable(feature = "atomic_access", since = "1.15.0")]

pub fn get_mut(&mut self) -> &mut bool {

// SAFETY: the mutable reference guarantees unique ownership.

unsafe { &mut *(self.v.get() as *mut bool) }

}

/// Get atomic access to a `&mut bool`.

///

/// # Examples

///

/// ```

/// #![feature(atomic_from_mut)]

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let mut some_bool = true;

/// let a = AtomicBool::from_mut(&mut some_bool);

/// a.store(false, Ordering::Relaxed);

/// assert_eq!(some_bool, false);

/// ```

#[inline]

#[cfg(target_has_atomic_equal_alignment = "8")]

#[unstable(feature = "atomic_from_mut", issue = "76314")]

pub fn from_mut(v: &mut bool) -> &mut Self {

// SAFETY: the mutable reference guarantees unique ownership, and

// alignment of both `bool` and `Self` is 1.

unsafe { &mut *(v as *mut bool as *mut Self) }

}

/// Get non-atomic access to a `&mut [AtomicBool]` slice.

///

/// This is safe because the mutable reference guarantees that no other threads are

/// concurrently accessing the atomic data.

///

/// # Examples

///

/// ```

/// #![feature(atomic_from_mut, inline_const)]

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let mut some_bools = [const { AtomicBool::new(false) }; 10];

///

/// let view: &mut [bool] = AtomicBool::get_mut_slice(&mut some_bools);

/// assert_eq!(view, [false; 10]);

/// view[..5].copy_from_slice(&[true; 5]);

///

/// std::thread::scope(|s| {

/// for t in &some_bools[..5] {

/// s.spawn(move || assert_eq!(t.load(Ordering::Relaxed), true));

/// }

///

/// for f in &some_bools[5..] {

/// s.spawn(move || assert_eq!(f.load(Ordering::Relaxed), false));

/// }

/// });

/// ```

#[inline]

#[unstable(feature = "atomic_from_mut", issue = "76314")]

pub fn get_mut_slice(this: &mut [Self]) -> &mut [bool] {

// SAFETY: the mutable reference guarantees unique ownership.

unsafe { &mut *(this as *mut [Self] as *mut [bool]) }

}

/// Get atomic access to a `&mut [bool]` slice.

///

/// # Examples

///

/// ```

/// #![feature(atomic_from_mut)]

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let mut some_bools = [false; 10];

/// let a = &*AtomicBool::from_mut_slice(&mut some_bools);

/// std::thread::scope(|s| {

/// for i in 0..a.len() {

/// s.spawn(move || a[i].store(true, Ordering::Relaxed));

/// }

/// });

/// assert_eq!(some_bools, [true; 10]);

/// ```

#[inline]

#[cfg(target_has_atomic_equal_alignment = "8")]

#[unstable(feature = "atomic_from_mut", issue = "76314")]

pub fn from_mut_slice(v: &mut [bool]) -> &mut [Self] {

// SAFETY: the mutable reference guarantees unique ownership, and

// alignment of both `bool` and `Self` is 1.

unsafe { &mut *(v as *mut [bool] as *mut [Self]) }

}

/// Consumes the atomic and returns the contained value.

///

/// This is safe because passing `self` by value guarantees that no other threads are

/// concurrently accessing the atomic data.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::AtomicBool;

///

/// let some_bool = AtomicBool::new(true);

/// assert_eq!(some_bool.into_inner(), true);

/// ```

#[inline]

#[stable(feature = "atomic_access", since = "1.15.0")]

#[rustc_const_unstable(feature = "const_cell_into_inner", issue = "78729")]

pub const fn into_inner(self) -> bool {

self.v.into_inner() != 0

}

/// Loads a value from the bool.

///

/// `load` takes an [`Ordering`] argument which describes the memory ordering

/// of this operation. Possible values are [`SeqCst`], [`Acquire`] and [`Relaxed`].

///

/// # Panics

///

/// Panics if `order` is [`Release`] or [`AcqRel`].

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let some_bool = AtomicBool::new(true);

///

/// assert_eq!(some_bool.load(Ordering::Relaxed), true);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

pub fn load(&self, order: Ordering) -> bool {

// SAFETY: any data races are prevented by atomic intrinsics and the raw

// pointer passed in is valid because we got it from a reference.

unsafe { atomic_load(self.v.get(), order) != 0 }

}

/// Stores a value into the bool.

///

/// `store` takes an [`Ordering`] argument which describes the memory ordering

/// of this operation. Possible values are [`SeqCst`], [`Release`] and [`Relaxed`].

///

/// # Panics

///

/// Panics if `order` is [`Acquire`] or [`AcqRel`].

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let some_bool = AtomicBool::new(true);

///

/// some_bool.store(false, Ordering::Relaxed);

/// assert_eq!(some_bool.load(Ordering::Relaxed), false);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

pub fn store(&self, val: bool, order: Ordering) {

// SAFETY: any data races are prevented by atomic intrinsics and the raw

// pointer passed in is valid because we got it from a reference.

unsafe {

atomic_store(self.v.get(), val as u8, order);

}

}

/// Stores a value into the bool, returning the previous value.

///

/// `swap` takes an [`Ordering`] argument which describes the memory ordering

/// of this operation. All ordering modes are possible. Note that using

/// [`Acquire`] makes the store part of this operation [`Relaxed`], and

/// using [`Release`] makes the load part [`Relaxed`].

///

/// **Note:** This method is only available on platforms that support atomic

/// operations on `u8`.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let some_bool = AtomicBool::new(true);

///

/// assert_eq!(some_bool.swap(false, Ordering::Relaxed), true);

/// assert_eq!(some_bool.load(Ordering::Relaxed), false);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

#[cfg(target_has_atomic = "8")]

pub fn swap(&self, val: bool, order: Ordering) -> bool {

// SAFETY: data races are prevented by atomic intrinsics.

unsafe { atomic_swap(self.v.get(), val as u8, order) != 0 }

}

/// Stores a value into the [`bool`] if the current value is the same as the `current` value.

///

/// The return value is always the previous value. If it is equal to `current`, then the value

/// was updated.

///

/// `compare_and_swap` also takes an [`Ordering`] argument which describes the memory

/// ordering of this operation. Notice that even when using [`AcqRel`], the operation

/// might fail and hence just perform an `Acquire` load, but not have `Release` semantics.

/// Using [`Acquire`] makes the store part of this operation [`Relaxed`] if it

/// happens, and using [`Release`] makes the load part [`Relaxed`].

///

/// **Note:** This method is only available on platforms that support atomic

/// operations on `u8`.

///

/// # Migrating to `compare_exchange` and `compare_exchange_weak`

///

/// `compare_and_swap` is equivalent to `compare_exchange` with the following mapping for

/// memory orderings:

///

/// Original | Success | Failure

/// -------- | ------- | -------

/// Relaxed | Relaxed | Relaxed

/// Acquire | Acquire | Acquire

/// Release | Release | Relaxed

/// AcqRel | AcqRel | Acquire

/// SeqCst | SeqCst | SeqCst

///

/// `compare_exchange_weak` is allowed to fail spuriously even when the comparison succeeds,

/// which allows the compiler to generate better assembly code when the compare and swap

/// is used in a loop.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let some_bool = AtomicBool::new(true);

///

/// assert_eq!(some_bool.compare_and_swap(true, false, Ordering::Relaxed), true);

/// assert_eq!(some_bool.load(Ordering::Relaxed), false);

///

/// assert_eq!(some_bool.compare_and_swap(true, true, Ordering::Relaxed), false);

/// assert_eq!(some_bool.load(Ordering::Relaxed), false);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

#[deprecated(

since = "1.50.0",

note = "Use `compare_exchange` or `compare_exchange_weak` instead"

)]

#[cfg(target_has_atomic = "8")]

pub fn compare_and_swap(&self, current: bool, new: bool, order: Ordering) -> bool {

match self.compare_exchange(current, new, order, strongest_failure_ordering(order)) {

Ok(x) => x,

Err(x) => x,

}

}

/// Stores a value into the [`bool`] if the current value is the same as the `current` value.

///

/// The return value is a result indicating whether the new value was written and containing

/// the previous value. On success this value is guaranteed to be equal to `current`.

///

/// `compare_exchange` takes two [`Ordering`] arguments to describe the memory

/// ordering of this operation. `success` describes the required ordering for the

/// read-modify-write operation that takes place if the comparison with `current` succeeds.

/// `failure` describes the required ordering for the load operation that takes place when

/// the comparison fails. Using [`Acquire`] as success ordering makes the store part

/// of this operation [`Relaxed`], and using [`Release`] makes the successful load

/// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]

/// and must be equivalent to or weaker than the success ordering.

///

/// **Note:** This method is only available on platforms that support atomic

/// operations on `u8`.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let some_bool = AtomicBool::new(true);

///

/// assert_eq!(some_bool.compare_exchange(true,

/// false,

/// Ordering::Acquire,

/// Ordering::Relaxed),

/// Ok(true));

/// assert_eq!(some_bool.load(Ordering::Relaxed), false);

///

/// assert_eq!(some_bool.compare_exchange(true, true,

/// Ordering::SeqCst,

/// Ordering::Acquire),

/// Err(false));

/// assert_eq!(some_bool.load(Ordering::Relaxed), false);

/// ```

#[inline]

#[stable(feature = "extended_compare_and_swap", since = "1.10.0")]

#[doc(alias = "compare_and_swap")]

#[cfg(target_has_atomic = "8")]

pub fn compare_exchange(

&self,

current: bool,

new: bool,

success: Ordering,

failure: Ordering,

) -> Result<bool, bool> {

// SAFETY: data races are prevented by atomic intrinsics.

match unsafe {

atomic_compare_exchange(self.v.get(), current as u8, new as u8, success, failure)

} {

Ok(x) => Ok(x != 0),

Err(x) => Err(x != 0),

}

}

/// Stores a value into the [`bool`] if the current value is the same as the `current` value.

///

/// Unlike [`AtomicBool::compare_exchange`], this function is allowed to spuriously fail even when the

/// comparison succeeds, which can result in more efficient code on some platforms. The

/// return value is a result indicating whether the new value was written and containing the

/// previous value.

///

/// `compare_exchange_weak` takes two [`Ordering`] arguments to describe the memory

/// ordering of this operation. `success` describes the required ordering for the

/// read-modify-write operation that takes place if the comparison with `current` succeeds.

/// `failure` describes the required ordering for the load operation that takes place when

/// the comparison fails. Using [`Acquire`] as success ordering makes the store part

/// of this operation [`Relaxed`], and using [`Release`] makes the successful load

/// [`Relaxed`]. The failure ordering can only be [`SeqCst`], [`Acquire`] or [`Relaxed`]

/// and must be equivalent to or weaker than the success ordering.

///

/// **Note:** This method is only available on platforms that support atomic

/// operations on `u8`.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let val = AtomicBool::new(false);

///

/// let new = true;

/// let mut old = val.load(Ordering::Relaxed);

/// loop {

/// match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {

/// Ok(_) => break,

/// Err(x) => old = x,

/// }

/// }

/// ```

#[inline]

#[stable(feature = "extended_compare_and_swap", since = "1.10.0")]

#[doc(alias = "compare_and_swap")]

#[cfg(target_has_atomic = "8")]

pub fn compare_exchange_weak(

&self,

current: bool,

new: bool,

success: Ordering,

failure: Ordering,

) -> Result<bool, bool> {

// SAFETY: data races are prevented by atomic intrinsics.

match unsafe {

atomic_compare_exchange_weak(self.v.get(), current as u8, new as u8, success, failure)

} {

Ok(x) => Ok(x != 0),

Err(x) => Err(x != 0),

}

}

/// Logical "and" with a boolean value.

///

/// Performs a logical "and" operation on the current value and the argument `val`, and sets

/// the new value to the result.

///

/// Returns the previous value.

///

/// `fetch_and` takes an [`Ordering`] argument which describes the memory ordering

/// of this operation. All ordering modes are possible. Note that using

/// [`Acquire`] makes the store part of this operation [`Relaxed`], and

/// using [`Release`] makes the load part [`Relaxed`].

///

/// **Note:** This method is only available on platforms that support atomic

/// operations on `u8`.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let foo = AtomicBool::new(true);

/// assert_eq!(foo.fetch_and(false, Ordering::SeqCst), true);

/// assert_eq!(foo.load(Ordering::SeqCst), false);

///

/// let foo = AtomicBool::new(true);

/// assert_eq!(foo.fetch_and(true, Ordering::SeqCst), true);

/// assert_eq!(foo.load(Ordering::SeqCst), true);

///

/// let foo = AtomicBool::new(false);

/// assert_eq!(foo.fetch_and(false, Ordering::SeqCst), false);

/// assert_eq!(foo.load(Ordering::SeqCst), false);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

#[cfg(target_has_atomic = "8")]

pub fn fetch_and(&self, val: bool, order: Ordering) -> bool {

// SAFETY: data races are prevented by atomic intrinsics.

unsafe { atomic_and(self.v.get(), val as u8, order) != 0 }

}

/// Logical "nand" with a boolean value.

///

/// Performs a logical "nand" operation on the current value and the argument `val`, and sets

/// the new value to the result.

///

/// Returns the previous value.

///

/// `fetch_nand` takes an [`Ordering`] argument which describes the memory ordering

/// of this operation. All ordering modes are possible. Note that using

/// [`Acquire`] makes the store part of this operation [`Relaxed`], and

/// using [`Release`] makes the load part [`Relaxed`].

///

/// **Note:** This method is only available on platforms that support atomic

/// operations on `u8`.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let foo = AtomicBool::new(true);

/// assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), true);

/// assert_eq!(foo.load(Ordering::SeqCst), true);

///

/// let foo = AtomicBool::new(true);

/// assert_eq!(foo.fetch_nand(true, Ordering::SeqCst), true);

/// assert_eq!(foo.load(Ordering::SeqCst) as usize, 0);

/// assert_eq!(foo.load(Ordering::SeqCst), false);

///

/// let foo = AtomicBool::new(false);

/// assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), false);

/// assert_eq!(foo.load(Ordering::SeqCst), true);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

#[cfg(target_has_atomic = "8")]

pub fn fetch_nand(&self, val: bool, order: Ordering) -> bool {

// We can't use atomic_nand here because it can result in a bool with

// an invalid value. This happens because the atomic operation is done

// with an 8-bit integer internally, which would set the upper 7 bits.

// So we just use fetch_xor or swap instead.

if val {

// !(x & true) == !x

// We must invert the bool.

self.fetch_xor(true, order)

} else {

// !(x & false) == true

// We must set the bool to true.

self.swap(true, order)

}

}

/// Logical "or" with a boolean value.

///

/// Performs a logical "or" operation on the current value and the argument `val`, and sets the

/// new value to the result.

///

/// Returns the previous value.

///

/// `fetch_or` takes an [`Ordering`] argument which describes the memory ordering

/// of this operation. All ordering modes are possible. Note that using

/// [`Acquire`] makes the store part of this operation [`Relaxed`], and

/// using [`Release`] makes the load part [`Relaxed`].

///

/// **Note:** This method is only available on platforms that support atomic

/// operations on `u8`.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let foo = AtomicBool::new(true);

/// assert_eq!(foo.fetch_or(false, Ordering::SeqCst), true);

/// assert_eq!(foo.load(Ordering::SeqCst), true);

///

/// let foo = AtomicBool::new(true);

/// assert_eq!(foo.fetch_or(true, Ordering::SeqCst), true);

/// assert_eq!(foo.load(Ordering::SeqCst), true);

///

/// let foo = AtomicBool::new(false);

/// assert_eq!(foo.fetch_or(false, Ordering::SeqCst), false);

/// assert_eq!(foo.load(Ordering::SeqCst), false);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

#[cfg(target_has_atomic = "8")]

pub fn fetch_or(&self, val: bool, order: Ordering) -> bool {

// SAFETY: data races are prevented by atomic intrinsics.

unsafe { atomic_or(self.v.get(), val as u8, order) != 0 }

}

/// Logical "xor" with a boolean value.

///

/// Performs a logical "xor" operation on the current value and the argument `val`, and sets

/// the new value to the result.

///

/// Returns the previous value.

///

/// `fetch_xor` takes an [`Ordering`] argument which describes the memory ordering

/// of this operation. All ordering modes are possible. Note that using

/// [`Acquire`] makes the store part of this operation [`Relaxed`], and

/// using [`Release`] makes the load part [`Relaxed`].

///

/// **Note:** This method is only available on platforms that support atomic

/// operations on `u8`.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let foo = AtomicBool::new(true);

/// assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), true);

/// assert_eq!(foo.load(Ordering::SeqCst), true);

///

/// let foo = AtomicBool::new(true);

/// assert_eq!(foo.fetch_xor(true, Ordering::SeqCst), true);

/// assert_eq!(foo.load(Ordering::SeqCst), false);

///

/// let foo = AtomicBool::new(false);

/// assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), false);

/// assert_eq!(foo.load(Ordering::SeqCst), false);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

#[cfg(target_has_atomic = "8")]

pub fn fetch_xor(&self, val: bool, order: Ordering) -> bool {

// SAFETY: data races are prevented by atomic intrinsics.

unsafe { atomic_xor(self.v.get(), val as u8, order) != 0 }

}

/// Returns a mutable pointer to the underlying [`bool`].

///

/// Doing non-atomic reads and writes on the resulting integer can be a data race.

/// This method is mostly useful for FFI, where the function signature may use

/// `*mut bool` instead of `&AtomicBool`.

///

/// Returning an `*mut` pointer from a shared reference to this atomic is safe because the

/// atomic types work with interior mutability. All modifications of an atomic change the value

/// through a shared reference, and can do so safely as long as they use atomic operations. Any

/// use of the returned raw pointer requires an `unsafe` block and still has to uphold the same

/// restriction: operations on it must be atomic.

///

/// # Examples

///

/// ```ignore (extern-declaration)

/// # fn main() {

/// use std::sync::atomic::AtomicBool;

/// extern "C" {

/// fn my_atomic_op(arg: *mut bool);

/// }

///

/// let mut atomic = AtomicBool::new(true);

/// unsafe {

/// my_atomic_op(atomic.as_mut_ptr());

/// }

/// # }

/// ```

#[inline]

#[unstable(feature = "atomic_mut_ptr", reason = "recently added", issue = "66893")]

pub fn as_mut_ptr(&self) -> *mut bool {

self.v.get() as *mut bool

}

/// 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)`.

///

/// Note: This may call the function multiple times if the value has been

/// changed from other threads in the meantime, as long as the function

/// returns `Some(_)`, but the function will have been applied only once to

/// the stored value.

///

/// `fetch_update` takes two [`Ordering`] arguments to describe the memory

/// ordering of this operation. The first describes the required ordering for

/// when the operation finally succeeds while the second describes the

/// required ordering for loads. These correspond to the success and failure

/// orderings of [`AtomicBool::compare_exchange`] respectively.

///

/// Using [`Acquire`] as success ordering makes the store part of this

/// operation [`Relaxed`], and using [`Release`] makes the final successful

/// load [`Relaxed`]. The (failed) load ordering can only be [`SeqCst`],

/// [`Acquire`] or [`Relaxed`] and must be equivalent to or weaker than the

/// success ordering.

///

/// **Note:** This method is only available on platforms that support atomic

/// operations on `u8`.

///

/// # Examples

///

/// ```rust

/// use std::sync::atomic::{AtomicBool, Ordering};

///

/// let x = AtomicBool::new(false);

/// assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(false));

/// assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(false));

/// assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(!x)), Ok(true));

/// assert_eq!(x.load(Ordering::SeqCst), false);

/// ```

#[inline]

#[stable(feature = "atomic_fetch_update", since = "1.53.0")]

#[cfg(target_has_atomic = "8")]

pub fn fetch_update<F>(

&self,

set_order: Ordering,

fetch_order: Ordering,

mut f: F,

) -> Result<bool, bool>

where

F: FnMut(bool) -> Option<bool>,

{

let mut prev = self.load(fetch_order);

while let Some(next) = f(prev) {

match self.compare_exchange_weak(prev, next, set_order, fetch_order) {

x @ Ok(_) => return x,

Err(next_prev) => prev = next_prev,

}

}

Err(prev)

}

/// Creates a new `AtomicPtr`.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::AtomicPtr;

///

/// let ptr = &mut 5;

/// let atomic_ptr = AtomicPtr::new(ptr);

/// ```

#[inline]

#[stable(feature = "rust1", since = "1.0.0")]

#[rustc_const_stable(feature = "const_atomic_new", since = "1.24.0")]

pub const fn new(p: *mut T) -> AtomicPtr<T> {

AtomicPtr { p: UnsafeCell::new(p) }

}

/// Returns a mutable reference to the underlying pointer.

///

/// This is safe because the mutable reference guarantees that no other threads are

/// concurrently accessing the atomic data.

///

/// # Examples

///

/// ```

/// use std::sync::atomic::{AtomicPtr, Ordering};

///

/// let mut data = 10;

/// let mut atomic_ptr = AtomicPtr::new(&mut data);

/// let mut other_data = 5;

/// *atomic_ptr.get_mut() = &mut other_data;

/// assert_eq!(unsafe { *atomic_ptr.load(Ordering::SeqCst) }, 5);

/// ```

#[inline]

#[stable(feature = "atomic_access", since = "1.15.0")]

pub fn get_mut(&mut self) -> &mut *mut T {

self.p.get_mut()

}

/// Get atomic access to a pointer.

///

/// # Examples

///

/// ```

/// #![feature(atomic_from_mut)]

/// use std::sync::atomic::{AtomicPtr, Ordering};

///

/// let mut data = 123;

/// let mut some_ptr = &mut data as *mut i32;

/// let a = AtomicPtr::from_mut(&mut some_ptr);

/// let mut other_data = 456;