Struct core::atomic::AtomicIsize [] [src]

pub struct AtomicIsize {
    // some fields omitted
}

A signed integer type which can be safely shared between threads.

Methods

impl AtomicIsize

const fn new(v: isize) -> AtomicIsize

Creates a new AtomicIsize.

Examples

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

let atomic_forty_two  = AtomicIsize::new(42);

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

Loads a value from the isize.

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::{AtomicIsize, Ordering}; let some_isize = AtomicIsize::new(5); assert_eq!(some_isize.load(Ordering::Relaxed), 5); }
use std::sync::atomic::{AtomicIsize, Ordering};

let some_isize = AtomicIsize::new(5);

assert_eq!(some_isize.load(Ordering::Relaxed), 5);

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

Stores a value into the isize.

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

Examples

fn main() { use std::sync::atomic::{AtomicIsize, Ordering}; let some_isize = AtomicIsize::new(5); some_isize.store(10, Ordering::Relaxed); assert_eq!(some_isize.load(Ordering::Relaxed), 10); }
use std::sync::atomic::{AtomicIsize, Ordering};

let some_isize = AtomicIsize::new(5);

some_isize.store(10, Ordering::Relaxed);
assert_eq!(some_isize.load(Ordering::Relaxed), 10);

Panics

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

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

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

let some_isize = AtomicIsize::new(5);

assert_eq!(some_isize.swap(10, Ordering::Relaxed), 5);

fn compare_and_swap(&self, current: isize, new: isize, order: Ordering) -> isize

Stores a value into the isize`isizeif the current value is the same as thecurrent` value.

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

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

Examples

fn main() { use std::sync::atomic::{AtomicIsize, Ordering}; let some_isize = AtomicIsize::new(5); assert_eq!(some_isize.compare_and_swap(5, 10, Ordering::Relaxed), 5); assert_eq!(some_isize.load(Ordering::Relaxed), 10); assert_eq!(some_isize.compare_and_swap(6, 12, Ordering::Relaxed), 10); assert_eq!(some_isize.load(Ordering::Relaxed), 10); }
use std::sync::atomic::{AtomicIsize, Ordering};

let some_isize = AtomicIsize::new(5);

assert_eq!(some_isize.compare_and_swap(5, 10, Ordering::Relaxed), 5);
assert_eq!(some_isize.load(Ordering::Relaxed), 10);

assert_eq!(some_isize.compare_and_swap(6, 12, Ordering::Relaxed), 10);
assert_eq!(some_isize.load(Ordering::Relaxed), 10);

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

Add an isize to the current value, returning the previous value.

Examples

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

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

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

Subtract an isize from the current value, returning the previous value.

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

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

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

Examples

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

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

Trait Implementations

impl Default for AtomicIsize

fn default() -> Self

impl Sync for AtomicIsize

impl Debug for AtomicIsize

fn fmt(&self, f: &mut Formatter) -> Result