Struct std::sync::atomic::AtomicUsizeStable
[-] [+]
[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.
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 takes an Ordering argument which describes the memory ordering of this operation.
Panics
Panics if order is Release or 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 takes an 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 is Acquire or AcqRel.
fn swap(&self, val: usize, order: Ordering) -> usize
Stores a value into the usize, returning the old value.
swap takes an 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.
If the return value is equal to old then the value was updated.
compare_and_swap also takes an 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));