Struct atomic_shim::AtomicU64[−][src]

pub struct AtomicU64 { /* fields omitted */ }

Expand description

An integer type which can be safely shared between threads.

Implementations

[src]

impl AtomicU64

[src]

pub fn new(v: u64) -> Self

Creates a new atomic integer.

Examples

use atomic_shim::AtomicU64;
let atomic_forty_two = AtomicU64::new(42);

[src]

pub fn get_mut(&mut self) -> &mut u64

Returns a mutable reference to the underlying integer.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

let mut some_var = AtomicU64::new(10);
assert_eq!(*some_var.get_mut(), 10);
*some_var.get_mut() = 5;
assert_eq!(some_var.load(Ordering::SeqCst), 5);

[src]

pub fn into_inner(self) -> u64

Consumes the atomic and returns the contained value.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::AtomicU64;
let some_var = AtomicU64::new(5);
assert_eq!(some_var.into_inner(), 5);

[src]

pub fn load(&self, _: Ordering) -> u64

Loads a value from the atomic integer.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;
let some_var = AtomicU64::new(5);
assert_eq!(some_var.load(Ordering::Relaxed), 5);

[src]

pub fn store(&self, value: u64, _: Ordering)

Stores a value into the atomic integer.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

let some_var = AtomicU64::new(5);
some_var.store(10, Ordering::Relaxed);
assert_eq!(some_var.load(Ordering::Relaxed), 10);

[src]

pub fn swap(&self, value: u64, _: Ordering) -> u64

Stores a value into the atomic integer, returning the previous value.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

let some_var = AtomicU64::new(5);
assert_eq!(some_var.swap(10, Ordering::Relaxed), 5);

[src]

pub fn compare_and_swap(&self, current: u64, new: u64, _: Ordering) -> u64

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

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

let some_var = AtomicU64::new(5);
assert_eq!(some_var.compare_and_swap(5, 10, Ordering::Relaxed), 5);
assert_eq!(some_var.load(Ordering::Relaxed), 10);
assert_eq!(some_var.compare_and_swap(6, 12, Ordering::Relaxed), 10);
assert_eq!(some_var.load(Ordering::Relaxed), 10);

[src]

pub fn compare_exchange(
 &self,
 current: u64,
 new: u64,
 _: Ordering,
 _: Ordering
) -> Result<u64, u64>

Stores a value into the atomic integer if the current value is the same as the current value.

The return value is a result indicating whether the new value was written and containing the previous value. On success this value is guaranteed to be equal to current.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

let some_var = AtomicU64::new(5);
assert_eq!(some_var.compare_exchange(5, 10,
                                     Ordering::Acquire,
                                     Ordering::Relaxed),
           Ok(5));
assert_eq!(some_var.load(Ordering::Relaxed), 10);
assert_eq!(some_var.compare_exchange(6, 12,
                                     Ordering::SeqCst,
                                     Ordering::Acquire),
           Err(10));
assert_eq!(some_var.load(Ordering::Relaxed), 10);

[src]

pub fn compare_exchange_weak(
 &self,
 current: u64,
 new: u64,
 success: Ordering,
 failure: Ordering
) -> Result<u64, u64>

Stores a value into the atomic integer if the current value is the same as the current value.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

let val = AtomicU64::new(4);
let mut old = val.load(Ordering::Relaxed);
loop {
    let new = old * 2;
    match val.compare_exchange_weak(old, new, Ordering::SeqCst, Ordering::Relaxed) {
        Ok(_) => break,
        Err(x) => old = x,
    }
}

[src]

pub fn fetch_add(&self, val: u64, _: Ordering) -> u64

Adds to the current value, returning the previous value.

This operation wraps around on overflow.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

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

[src]

pub fn fetch_sub(&self, val: u64, _: Ordering) -> u64

Subtracts from the current value, returning the previous value.

This operation wraps around on overflow.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

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

[src]

pub fn fetch_and(&self, val: u64, _: Ordering) -> u64

Bitwise “and” with the current value.

Performs a bitwise “and” operation on the current value and the argument val, and sets the new value to the result. Returns the previous value.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

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

[src]

pub fn fetch_nand(&self, val: u64, _: Ordering) -> u64

Bitwise “nand” with the current value.

Performs a bitwise “nand” operation on the current value and the argument val, and sets the new value to the result. Returns the previous value.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

let foo = AtomicU64::new(0x13);
assert_eq!(foo.fetch_nand(0x31, Ordering::SeqCst), 0x13);
assert_eq!(foo.load(Ordering::SeqCst), !(0x13 & 0x31));

[src]

pub fn fetch_or(&self, val: u64, _: Ordering) -> u64

Bitwise “or” with the current value.

Performs a bitwise “or” operation on the current value and the argument val, and sets the new value to the result. Returns the previous value.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;

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

[src]

pub fn fetch_xor(&self, val: u64, _: Ordering) -> u64

Bitwise “xor” with the current value.

Performs a bitwise “xor” operation on the current value and the argument val, and sets the new value to the result. Returns the previous value.

It ignores the Ordering argument, but it is required for compatibility with std::sync::AtomicU64

Panics

Panics if the Mutex is poisoned

Examples

use std::sync::atomic::Ordering;
use atomic_shim::AtomicU64;
let foo = AtomicU64::new(0b101101);
assert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101);
assert_eq!(foo.load(Ordering::SeqCst), 0b011110);