Struct core::atomic::AtomicBool [] [src]

pub struct AtomicBool {
    // some fields omitted
}

A boolean type which can be safely shared between threads.

Methods

impl AtomicBool

fn new(v: bool) -> AtomicBool

Creates a new AtomicBool`AtomicBool`.

Examples

fn main() { use std::sync::atomic::AtomicBool; let atomic_true = AtomicBool::new(true); let atomic_false = AtomicBool::new(false); }
use std::sync::atomic::AtomicBool;

let atomic_true  = AtomicBool::new(true);
let atomic_false = AtomicBool::new(false);

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

Loads a value from the bool.

load`loadtakes an` takes an Ordering`Ordering` argument which describes the memory ordering of this operation.

Panics

Panics if order`orderis` is Release`Releaseor` or AcqRel`AcqRel`.

Examples

fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); let value = some_bool.load(Ordering::Relaxed); }
use std::sync::atomic::{AtomicBool, Ordering};

let some_bool = AtomicBool::new(true);

let value = some_bool.load(Ordering::Relaxed);

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

Stores a value into the bool.

store`storetakes an` takes an Ordering`Ordering` argument which describes the memory ordering of this operation.

Examples

fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); some_bool.store(false, Ordering::Relaxed); }
use std::sync::atomic::{AtomicBool, Ordering};

let some_bool = AtomicBool::new(true);

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

Panics

Panics if order`orderis` is Acquire`Acquireor` or AcqRel`AcqRel`.

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

Stores a value into the bool, returning the old value.

swap`swaptakes an` takes an Ordering`Ordering` argument which describes the memory ordering of this operation.

Examples

fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); let value = some_bool.swap(false, Ordering::Relaxed); }
use std::sync::atomic::{AtomicBool, Ordering};

let some_bool = AtomicBool::new(true);

let value = some_bool.swap(false, Ordering::Relaxed);

fn compare_and_swap(&self, old: bool, new: bool, order: Ordering) -> bool

Stores a value into the bool if the current value is the same as the expected value.

The return value is always the previous value. If it is equal to old`old`, then the value was updated.

swap`swapalso takes an` also takes an Ordering`Ordering` argument which describes the memory ordering of this operation.

Examples

fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let some_bool = AtomicBool::new(true); let value = some_bool.store(false, Ordering::Relaxed); }
use std::sync::atomic::{AtomicBool, Ordering};

let some_bool = AtomicBool::new(true);

let value = some_bool.store(false, Ordering::Relaxed);

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

Logical "and" with a boolean value.

Performs a logical "and" operation on the current value and the argument val`val`, and sets the new value to the result.

Returns the previous value.

Examples

fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_and(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_and(true, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_and(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); }
use std::sync::atomic::{AtomicBool, Ordering};

let foo = AtomicBool::new(true);
assert_eq!(true, foo.fetch_and(false, Ordering::SeqCst));
assert_eq!(false, foo.load(Ordering::SeqCst));

let foo = AtomicBool::new(true);
assert_eq!(true, foo.fetch_and(true, Ordering::SeqCst));
assert_eq!(true, foo.load(Ordering::SeqCst));

let foo = AtomicBool::new(false);
assert_eq!(false, foo.fetch_and(false, Ordering::SeqCst));
assert_eq!(false, foo.load(Ordering::SeqCst));

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

Logical "nand" with a boolean value.

Performs a logical "nand" operation on the current value and the argument val`val`, and sets the new value to the result.

Returns the previous value.

Examples

fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_nand(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_nand(true, Ordering::SeqCst)); assert_eq!(0, foo.load(Ordering::SeqCst) as usize); assert_eq!(false, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_nand(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); }
use std::sync::atomic::{AtomicBool, Ordering};

let foo = AtomicBool::new(true);
assert_eq!(true, foo.fetch_nand(false, Ordering::SeqCst));
assert_eq!(true, foo.load(Ordering::SeqCst));

let foo = AtomicBool::new(true);
assert_eq!(true, foo.fetch_nand(true, Ordering::SeqCst));
assert_eq!(0, foo.load(Ordering::SeqCst) as usize);
assert_eq!(false, foo.load(Ordering::SeqCst));

let foo = AtomicBool::new(false);
assert_eq!(false, foo.fetch_nand(false, Ordering::SeqCst));
assert_eq!(true, foo.load(Ordering::SeqCst));

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

Logical "or" with a boolean value.

Performs a logical "or" operation on the current value and the argument val`val`, and sets the new value to the result.

Returns the previous value.

Examples

fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_or(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_or(true, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_or(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); }
use std::sync::atomic::{AtomicBool, Ordering};

let foo = AtomicBool::new(true);
assert_eq!(true, foo.fetch_or(false, Ordering::SeqCst));
assert_eq!(true, foo.load(Ordering::SeqCst));

let foo = AtomicBool::new(true);
assert_eq!(true, foo.fetch_or(true, Ordering::SeqCst));
assert_eq!(true, foo.load(Ordering::SeqCst));

let foo = AtomicBool::new(false);
assert_eq!(false, foo.fetch_or(false, Ordering::SeqCst));
assert_eq!(false, foo.load(Ordering::SeqCst));

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

Logical "xor" with a boolean value.

Performs a logical "xor" operation on the current value and the argument val`val`, and sets the new value to the result.

Returns the previous value.

Examples

fn main() { use std::sync::atomic::{AtomicBool, Ordering}; let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_xor(false, Ordering::SeqCst)); assert_eq!(true, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(true); assert_eq!(true, foo.fetch_xor(true, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); let foo = AtomicBool::new(false); assert_eq!(false, foo.fetch_xor(false, Ordering::SeqCst)); assert_eq!(false, foo.load(Ordering::SeqCst)); }
use std::sync::atomic::{AtomicBool, Ordering};

let foo = AtomicBool::new(true);
assert_eq!(true, foo.fetch_xor(false, Ordering::SeqCst));
assert_eq!(true, foo.load(Ordering::SeqCst));

let foo = AtomicBool::new(true);
assert_eq!(true, foo.fetch_xor(true, Ordering::SeqCst));
assert_eq!(false, foo.load(Ordering::SeqCst));

let foo = AtomicBool::new(false);
assert_eq!(false, foo.fetch_xor(false, Ordering::SeqCst));
assert_eq!(false, foo.load(Ordering::SeqCst));

Trait Implementations

impl Default for AtomicBool

fn default() -> AtomicBool

impl Sync for AtomicBool