Struct std::sync::atomic::AtomicIsize
[−]
[src]
pub struct AtomicIsize { v: UnsafeCell<isize>, }
A signed integer type which can be safely shared between threads.
Fields
v |
Methods
impl AtomicIsize
const fn new(v: isize) -> AtomicIsize
Creates a new AtomicIsize
.
Examples
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
takes an Ordering
argument which describes the memory ordering of this operation.
Panics
Panics if order
is Release
or AcqRel
.
Examples
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
takes an Ordering
argument which describes the memory ordering of this operation.
Examples
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
is Acquire
or AcqRel
.
fn swap(&self, val: isize, order: Ordering) -> isize
Stores a value into the isize, returning the old value.
swap
takes an Ordering
argument which describes the memory ordering of this operation.
Examples
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
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.
Examples
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
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
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
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
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
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);