Struct std::sync::atomic::AtomicUsize [] [src]

pub struct AtomicUsize {
    // some fields omitted
}

An unsigned integer type which can be safely shared between threads.

Methods

impl AtomicUsize

fn new(v: usize) -> AtomicUsize

Creates a new AtomicUsize`AtomicUsize`.

Examples

fn main() { use std::sync::atomic::AtomicUsize; let atomic_forty_two = AtomicUsize::new(42); }
use std::sync::atomic::AtomicUsize;

let atomic_forty_two = AtomicUsize::new(42);

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

Loads a value from the usize.

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::{AtomicUsize, Ordering}; let some_usize = AtomicUsize::new(5); let value = some_usize.load(Ordering::Relaxed); }
use std::sync::atomic::{AtomicUsize, Ordering};

let some_usize = AtomicUsize::new(5);

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

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

Stores a value into the usize.

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

Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let some_usize = AtomicUsize::new(5); some_usize.store(10, Ordering::Relaxed); }
use std::sync::atomic::{AtomicUsize, Ordering};

let some_usize = AtomicUsize::new(5);

some_usize.store(10, Ordering::Relaxed);

Panics

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

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

Stores a value into the usize, 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::{AtomicUsize, Ordering}; let some_usize= AtomicUsize::new(5); let value = some_usize.swap(10, Ordering::Relaxed); }
use std::sync::atomic::{AtomicUsize, Ordering};

let some_usize= AtomicUsize::new(5);

let value = some_usize.swap(10, Ordering::Relaxed);

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

Stores a value into the usize 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.

compare_and_swap`compare_and_swapalso takes an` also takes an Ordering`Ordering` argument which describes the memory ordering of this operation.

Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let some_usize = AtomicUsize::new(5); let value = some_usize.compare_and_swap(5, 10, Ordering::Relaxed); }
use std::sync::atomic::{AtomicUsize, Ordering};

let some_usize = AtomicUsize::new(5);

let value = some_usize.compare_and_swap(5, 10, Ordering::Relaxed);

fn fetch_add(&self, val: usize, order: Ordering) -> usize

Add to the current usize, returning the previous value.

Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(0); assert_eq!(0, foo.fetch_add(10, Ordering::SeqCst)); assert_eq!(10, foo.load(Ordering::SeqCst)); }
use std::sync::atomic::{AtomicUsize, Ordering};

let foo = AtomicUsize::new(0);
assert_eq!(0, foo.fetch_add(10, Ordering::SeqCst));
assert_eq!(10, foo.load(Ordering::SeqCst));

fn fetch_sub(&self, val: usize, order: Ordering) -> usize

Subtract from the current usize, returning the previous value.

Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(10); assert_eq!(10, foo.fetch_sub(10, Ordering::SeqCst)); assert_eq!(0, foo.load(Ordering::SeqCst)); }
use std::sync::atomic::{AtomicUsize, Ordering};

let foo = AtomicUsize::new(10);
assert_eq!(10, foo.fetch_sub(10, Ordering::SeqCst));
assert_eq!(0, foo.load(Ordering::SeqCst));

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

Bitwise and with the current usize, returning the previous value.

Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(0b101101); assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst)); assert_eq!(0b100001, foo.load(Ordering::SeqCst)); }
use std::sync::atomic::{AtomicUsize, Ordering};

let foo = AtomicUsize::new(0b101101);
assert_eq!(0b101101, foo.fetch_and(0b110011, Ordering::SeqCst));
assert_eq!(0b100001, foo.load(Ordering::SeqCst));

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

Bitwise or with the current usize, returning the previous value.

Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(0b101101); assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst)); assert_eq!(0b111111, foo.load(Ordering::SeqCst)); }
use std::sync::atomic::{AtomicUsize, Ordering};

let foo = AtomicUsize::new(0b101101);
assert_eq!(0b101101, foo.fetch_or(0b110011, Ordering::SeqCst));
assert_eq!(0b111111, foo.load(Ordering::SeqCst));

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

Bitwise xor with the current usize, returning the previous value.

Examples

fn main() { use std::sync::atomic::{AtomicUsize, Ordering}; let foo = AtomicUsize::new(0b101101); assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst)); assert_eq!(0b011110, foo.load(Ordering::SeqCst)); }
use std::sync::atomic::{AtomicUsize, Ordering};

let foo = AtomicUsize::new(0b101101);
assert_eq!(0b101101, foo.fetch_xor(0b110011, Ordering::SeqCst));
assert_eq!(0b011110, foo.load(Ordering::SeqCst));

Trait Implementations

impl Default for AtomicUsize

fn default() -> AtomicUsize

impl Sync for AtomicUsize