[−][src]Struct atomic_shim::AtomicU64
An integer type which can be safely shared between threads.
Implementations
impl AtomicU64
[src]
pub fn new(v: u64) -> Self
[src]
Creates a new atomic integer.
Examples
use atomic_shim::AtomicU64; let atomic_forty_two = AtomicU64::new(42);
pub fn get_mut(&mut self) -> &mut u64
[src]
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);
pub fn into_inner(self) -> u64
[src]
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);
pub fn load(&self, _: Ordering) -> u64
[src]
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);
pub fn store(&self, value: u64, _: Ordering)
[src]
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);
pub fn swap(&self, value: u64, _: Ordering) -> u64
[src]
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);
pub fn compare_and_swap(&self, current: u64, new: u64, _: Ordering) -> u64
[src]
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);
pub fn compare_exchange(
&self,
current: u64,
new: u64,
_: Ordering,
_: Ordering
) -> Result<u64, u64>
[src]
&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);
pub fn compare_exchange_weak(
&self,
current: u64,
new: u64,
success: Ordering,
failure: Ordering
) -> Result<u64, u64>
[src]
&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, } }
pub fn fetch_add(&self, val: u64, _: Ordering) -> u64
[src]
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);
pub fn fetch_sub(&self, val: u64, _: Ordering) -> u64
[src]
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);
pub fn fetch_and(&self, val: u64, _: Ordering) -> u64
[src]
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);
pub fn fetch_nand(&self, val: u64, _: Ordering) -> u64
[src]
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));
pub fn fetch_or(&self, val: u64, _: Ordering) -> u64
[src]
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);
pub fn fetch_xor(&self, val: u64, _: Ordering) -> u64
[src]
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);
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for AtomicU64
impl Send for AtomicU64
impl Sync for AtomicU64
impl Unpin for AtomicU64
impl UnwindSafe for AtomicU64
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,