[−][src]Trait radium::Radium
A maybe-atomic shared mutable fundamental type T
.
This trait is implemented by both the atomic wrapper type for T
, and by
Cell<T>
, providing a consistent interface for interacting with the two
types.
This trait provides methods predicated on marker traits for the underlying
fundamental. Only types which can be viewed as sequences of bits may use the
functions for bit-wise arithmetic, and only types which can be used as
integers may use the functions for numeric arithmetic. Use of these methods
on insufficient underlying types (for example, Radium::fetch_and
on an
atomic or cell-wrapped pointer) will cause a compiler error.
Associated Types
Loading content...Required methods
pub fn new(value: Self::Item) -> Self
[src]
Creates a new value of this type.
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut Self::Item
[src]
Returns a mutable reference to the underlying value.
This is safe because the mutable reference to self
guarantees that no
other references exist to this value.
pub fn into_inner(self) -> Self::Item
[src]
Consumes the wrapper and returns the contained value.
This is safe as passing by value ensures no other references exist.
pub fn load(&self, order: Ordering) -> Self::Item
[src]
Load a value from this object.
Ordering values are ignored by non-atomic types.
See also: AtomicUsize::load
.
pub fn store(&self, value: Self::Item, order: Ordering)
[src]
Store a value in this object.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::store
.
pub fn swap(&self, value: Self::Item, order: Ordering) -> Self::Item
[src]
Swap with the value stored in this object.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::swap
.
pub fn compare_and_swap(
&self,
current: Self::Item,
new: Self::Item,
order: Ordering
) -> Self::Item
[src]
&self,
current: Self::Item,
new: Self::Item,
order: Ordering
) -> Self::Item
Stores a value into this object if the currently-stored value is the
same as the current
value.
The return value is always the previously-stored value. If it is equal to
current
, then the value was updated with new
.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::compare_and_swap
.
pub fn compare_exchange(
&self,
current: Self::Item,
new: Self::Item,
success: Ordering,
failure: Ordering
) -> Result<Self::Item, Self::Item>
[src]
&self,
current: Self::Item,
new: Self::Item,
success: Ordering,
failure: Ordering
) -> Result<Self::Item, Self::Item>
Stores a value into this object if the currently-stored value is the
same as the current
value.
The return value is a Result
indicating whether the new value was
written, and containing the previously-stored value. On success, this
value is guaranteed to be equal to current
.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::compare_exchange
.
pub fn compare_exchange_weak(
&self,
current: Self::Item,
new: Self::Item,
success: Ordering,
failure: Ordering
) -> Result<Self::Item, Self::Item>
[src]
&self,
current: Self::Item,
new: Self::Item,
success: Ordering,
failure: Ordering
) -> Result<Self::Item, Self::Item>
Stores a value into this object if the currently-stored value is the
same as the current
value.
Unlike compare_exchange
, this function is allowed to spuriously fail
even when the comparison succeeds, which can result in more efficient
code on some platforms. The return value is a Result
indicating
whether the new value was written, and containing the previously-stored
value.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::compare_exchange_weak
.
pub fn fetch_and(&self, value: Self::Item, order: Ordering) -> Self::Item where
Self::Item: BitOps,
[src]
Self::Item: BitOps,
Performs a bitwise "and" on the currently-stored value and the argument
value
, and stores the result in self
.
Returns the previously-stored value.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::fetch_and
.
pub fn fetch_nand(&self, value: Self::Item, order: Ordering) -> Self::Item where
Self::Item: BitOps,
[src]
Self::Item: BitOps,
Performs a bitwise "nand" on the currently-stored value and the argument
value
, and stores the result in self
.
Returns the previously-stored value.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::fetch_nand
.
pub fn fetch_or(&self, value: Self::Item, order: Ordering) -> Self::Item where
Self::Item: BitOps,
[src]
Self::Item: BitOps,
Performs a bitwise "or" on the currently-stored value and the argument
value
, and stores the result in self
.
Returns the previously-stored value.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::fetch_or
.
pub fn fetch_xor(&self, value: Self::Item, order: Ordering) -> Self::Item where
Self::Item: BitOps,
[src]
Self::Item: BitOps,
Performs a bitwise "xor" on the currently-stored value and the argument
value
, and stores the result in self
.
Returns the previously-stored value.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::fetch_xor
.
pub fn fetch_add(&self, value: Self::Item, order: Ordering) -> Self::Item where
Self::Item: NumericOps,
[src]
Self::Item: NumericOps,
Adds value
to the currently-stored value, wrapping on overflow, and
stores the result in self
.
Returns the previously-stored value.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::fetch_add
.
pub fn fetch_sub(&self, value: Self::Item, order: Ordering) -> Self::Item where
Self::Item: NumericOps,
[src]
Self::Item: NumericOps,
Subtracts value
from the currently-stored value, wrapping on
underflow, and stores the result in self
.
Returns the previously-stored value.
Ordering arguments are ignored by non-atomic types.
See also: AtomicUsize::fetch_sub
.
Implementations on Foreign Types
impl Radium for AtomicI8
[src]
type Item = i8
pub fn new(value: i8) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut i8
[src]
pub fn into_inner(self) -> i8
[src]
pub fn load(&self, order: Ordering) -> i8
[src]
pub fn store(&self, value: i8, order: Ordering)
[src]
pub fn swap(&self, value: i8, order: Ordering) -> i8
[src]
pub fn compare_and_swap(&self, current: i8, new: i8, order: Ordering) -> i8
[src]
pub fn compare_exchange(
&self,
current: i8,
new: i8,
success: Ordering,
failure: Ordering
) -> Result<i8, i8>
[src]
&self,
current: i8,
new: i8,
success: Ordering,
failure: Ordering
) -> Result<i8, i8>
pub fn compare_exchange_weak(
&self,
current: i8,
new: i8,
success: Ordering,
failure: Ordering
) -> Result<i8, i8>
[src]
&self,
current: i8,
new: i8,
success: Ordering,
failure: Ordering
) -> Result<i8, i8>
pub fn fetch_and(&self, value: i8, order: Ordering) -> i8
[src]
pub fn fetch_nand(&self, value: i8, order: Ordering) -> i8
[src]
pub fn fetch_or(&self, value: i8, order: Ordering) -> i8
[src]
pub fn fetch_xor(&self, value: i8, order: Ordering) -> i8
[src]
pub fn fetch_add(&self, value: i8, order: Ordering) -> i8
[src]
pub fn fetch_sub(&self, value: i8, order: Ordering) -> i8
[src]
impl Radium for Cell<i8>
[src]
type Item = i8
pub fn new(value: i8) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut i8
[src]
pub fn into_inner(self) -> i8
[src]
pub fn load(&self, _: Ordering) -> i8
[src]
pub fn store(&self, value: i8, _: Ordering)
[src]
pub fn swap(&self, value: i8, _: Ordering) -> i8
[src]
pub fn compare_and_swap(&self, current: i8, new: i8, _: Ordering) -> i8
[src]
pub fn compare_exchange(
&self,
current: i8,
new: i8,
_: Ordering,
_: Ordering
) -> Result<i8, i8>
[src]
&self,
current: i8,
new: i8,
_: Ordering,
_: Ordering
) -> Result<i8, i8>
pub fn compare_exchange_weak(
&self,
current: i8,
new: i8,
success: Ordering,
failure: Ordering
) -> Result<i8, i8>
[src]
&self,
current: i8,
new: i8,
success: Ordering,
failure: Ordering
) -> Result<i8, i8>
pub fn fetch_and(&self, value: i8, _: Ordering) -> i8
[src]
pub fn fetch_nand(&self, value: i8, _: Ordering) -> i8
[src]
pub fn fetch_or(&self, value: i8, _: Ordering) -> i8
[src]
pub fn fetch_xor(&self, value: i8, _: Ordering) -> i8
[src]
pub fn fetch_add(&self, value: i8, _: Ordering) -> i8
[src]
pub fn fetch_sub(&self, value: i8, _: Ordering) -> i8
[src]
impl Radium for AtomicU8
[src]
type Item = u8
pub fn new(value: u8) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut u8
[src]
pub fn into_inner(self) -> u8
[src]
pub fn load(&self, order: Ordering) -> u8
[src]
pub fn store(&self, value: u8, order: Ordering)
[src]
pub fn swap(&self, value: u8, order: Ordering) -> u8
[src]
pub fn compare_and_swap(&self, current: u8, new: u8, order: Ordering) -> u8
[src]
pub fn compare_exchange(
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
[src]
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
pub fn compare_exchange_weak(
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
[src]
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
pub fn fetch_and(&self, value: u8, order: Ordering) -> u8
[src]
pub fn fetch_nand(&self, value: u8, order: Ordering) -> u8
[src]
pub fn fetch_or(&self, value: u8, order: Ordering) -> u8
[src]
pub fn fetch_xor(&self, value: u8, order: Ordering) -> u8
[src]
pub fn fetch_add(&self, value: u8, order: Ordering) -> u8
[src]
pub fn fetch_sub(&self, value: u8, order: Ordering) -> u8
[src]
impl Radium for Cell<u8>
[src]
type Item = u8
pub fn new(value: u8) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut u8
[src]
pub fn into_inner(self) -> u8
[src]
pub fn load(&self, _: Ordering) -> u8
[src]
pub fn store(&self, value: u8, _: Ordering)
[src]
pub fn swap(&self, value: u8, _: Ordering) -> u8
[src]
pub fn compare_and_swap(&self, current: u8, new: u8, _: Ordering) -> u8
[src]
pub fn compare_exchange(
&self,
current: u8,
new: u8,
_: Ordering,
_: Ordering
) -> Result<u8, u8>
[src]
&self,
current: u8,
new: u8,
_: Ordering,
_: Ordering
) -> Result<u8, u8>
pub fn compare_exchange_weak(
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
[src]
&self,
current: u8,
new: u8,
success: Ordering,
failure: Ordering
) -> Result<u8, u8>
pub fn fetch_and(&self, value: u8, _: Ordering) -> u8
[src]
pub fn fetch_nand(&self, value: u8, _: Ordering) -> u8
[src]
pub fn fetch_or(&self, value: u8, _: Ordering) -> u8
[src]
pub fn fetch_xor(&self, value: u8, _: Ordering) -> u8
[src]
pub fn fetch_add(&self, value: u8, _: Ordering) -> u8
[src]
pub fn fetch_sub(&self, value: u8, _: Ordering) -> u8
[src]
impl Radium for AtomicI16
[src]
type Item = i16
pub fn new(value: i16) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut i16
[src]
pub fn into_inner(self) -> i16
[src]
pub fn load(&self, order: Ordering) -> i16
[src]
pub fn store(&self, value: i16, order: Ordering)
[src]
pub fn swap(&self, value: i16, order: Ordering) -> i16
[src]
pub fn compare_and_swap(&self, current: i16, new: i16, order: Ordering) -> i16
[src]
pub fn compare_exchange(
&self,
current: i16,
new: i16,
success: Ordering,
failure: Ordering
) -> Result<i16, i16>
[src]
&self,
current: i16,
new: i16,
success: Ordering,
failure: Ordering
) -> Result<i16, i16>
pub fn compare_exchange_weak(
&self,
current: i16,
new: i16,
success: Ordering,
failure: Ordering
) -> Result<i16, i16>
[src]
&self,
current: i16,
new: i16,
success: Ordering,
failure: Ordering
) -> Result<i16, i16>
pub fn fetch_and(&self, value: i16, order: Ordering) -> i16
[src]
pub fn fetch_nand(&self, value: i16, order: Ordering) -> i16
[src]
pub fn fetch_or(&self, value: i16, order: Ordering) -> i16
[src]
pub fn fetch_xor(&self, value: i16, order: Ordering) -> i16
[src]
pub fn fetch_add(&self, value: i16, order: Ordering) -> i16
[src]
pub fn fetch_sub(&self, value: i16, order: Ordering) -> i16
[src]
impl Radium for Cell<i16>
[src]
type Item = i16
pub fn new(value: i16) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut i16
[src]
pub fn into_inner(self) -> i16
[src]
pub fn load(&self, _: Ordering) -> i16
[src]
pub fn store(&self, value: i16, _: Ordering)
[src]
pub fn swap(&self, value: i16, _: Ordering) -> i16
[src]
pub fn compare_and_swap(&self, current: i16, new: i16, _: Ordering) -> i16
[src]
pub fn compare_exchange(
&self,
current: i16,
new: i16,
_: Ordering,
_: Ordering
) -> Result<i16, i16>
[src]
&self,
current: i16,
new: i16,
_: Ordering,
_: Ordering
) -> Result<i16, i16>
pub fn compare_exchange_weak(
&self,
current: i16,
new: i16,
success: Ordering,
failure: Ordering
) -> Result<i16, i16>
[src]
&self,
current: i16,
new: i16,
success: Ordering,
failure: Ordering
) -> Result<i16, i16>
pub fn fetch_and(&self, value: i16, _: Ordering) -> i16
[src]
pub fn fetch_nand(&self, value: i16, _: Ordering) -> i16
[src]
pub fn fetch_or(&self, value: i16, _: Ordering) -> i16
[src]
pub fn fetch_xor(&self, value: i16, _: Ordering) -> i16
[src]
pub fn fetch_add(&self, value: i16, _: Ordering) -> i16
[src]
pub fn fetch_sub(&self, value: i16, _: Ordering) -> i16
[src]
impl Radium for AtomicU16
[src]
type Item = u16
pub fn new(value: u16) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut u16
[src]
pub fn into_inner(self) -> u16
[src]
pub fn load(&self, order: Ordering) -> u16
[src]
pub fn store(&self, value: u16, order: Ordering)
[src]
pub fn swap(&self, value: u16, order: Ordering) -> u16
[src]
pub fn compare_and_swap(&self, current: u16, new: u16, order: Ordering) -> u16
[src]
pub fn compare_exchange(
&self,
current: u16,
new: u16,
success: Ordering,
failure: Ordering
) -> Result<u16, u16>
[src]
&self,
current: u16,
new: u16,
success: Ordering,
failure: Ordering
) -> Result<u16, u16>
pub fn compare_exchange_weak(
&self,
current: u16,
new: u16,
success: Ordering,
failure: Ordering
) -> Result<u16, u16>
[src]
&self,
current: u16,
new: u16,
success: Ordering,
failure: Ordering
) -> Result<u16, u16>
pub fn fetch_and(&self, value: u16, order: Ordering) -> u16
[src]
pub fn fetch_nand(&self, value: u16, order: Ordering) -> u16
[src]
pub fn fetch_or(&self, value: u16, order: Ordering) -> u16
[src]
pub fn fetch_xor(&self, value: u16, order: Ordering) -> u16
[src]
pub fn fetch_add(&self, value: u16, order: Ordering) -> u16
[src]
pub fn fetch_sub(&self, value: u16, order: Ordering) -> u16
[src]
impl Radium for Cell<u16>
[src]
type Item = u16
pub fn new(value: u16) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut u16
[src]
pub fn into_inner(self) -> u16
[src]
pub fn load(&self, _: Ordering) -> u16
[src]
pub fn store(&self, value: u16, _: Ordering)
[src]
pub fn swap(&self, value: u16, _: Ordering) -> u16
[src]
pub fn compare_and_swap(&self, current: u16, new: u16, _: Ordering) -> u16
[src]
pub fn compare_exchange(
&self,
current: u16,
new: u16,
_: Ordering,
_: Ordering
) -> Result<u16, u16>
[src]
&self,
current: u16,
new: u16,
_: Ordering,
_: Ordering
) -> Result<u16, u16>
pub fn compare_exchange_weak(
&self,
current: u16,
new: u16,
success: Ordering,
failure: Ordering
) -> Result<u16, u16>
[src]
&self,
current: u16,
new: u16,
success: Ordering,
failure: Ordering
) -> Result<u16, u16>
pub fn fetch_and(&self, value: u16, _: Ordering) -> u16
[src]
pub fn fetch_nand(&self, value: u16, _: Ordering) -> u16
[src]
pub fn fetch_or(&self, value: u16, _: Ordering) -> u16
[src]
pub fn fetch_xor(&self, value: u16, _: Ordering) -> u16
[src]
pub fn fetch_add(&self, value: u16, _: Ordering) -> u16
[src]
pub fn fetch_sub(&self, value: u16, _: Ordering) -> u16
[src]
impl Radium for AtomicI32
[src]
type Item = i32
pub fn new(value: i32) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut i32
[src]
pub fn into_inner(self) -> i32
[src]
pub fn load(&self, order: Ordering) -> i32
[src]
pub fn store(&self, value: i32, order: Ordering)
[src]
pub fn swap(&self, value: i32, order: Ordering) -> i32
[src]
pub fn compare_and_swap(&self, current: i32, new: i32, order: Ordering) -> i32
[src]
pub fn compare_exchange(
&self,
current: i32,
new: i32,
success: Ordering,
failure: Ordering
) -> Result<i32, i32>
[src]
&self,
current: i32,
new: i32,
success: Ordering,
failure: Ordering
) -> Result<i32, i32>
pub fn compare_exchange_weak(
&self,
current: i32,
new: i32,
success: Ordering,
failure: Ordering
) -> Result<i32, i32>
[src]
&self,
current: i32,
new: i32,
success: Ordering,
failure: Ordering
) -> Result<i32, i32>
pub fn fetch_and(&self, value: i32, order: Ordering) -> i32
[src]
pub fn fetch_nand(&self, value: i32, order: Ordering) -> i32
[src]
pub fn fetch_or(&self, value: i32, order: Ordering) -> i32
[src]
pub fn fetch_xor(&self, value: i32, order: Ordering) -> i32
[src]
pub fn fetch_add(&self, value: i32, order: Ordering) -> i32
[src]
pub fn fetch_sub(&self, value: i32, order: Ordering) -> i32
[src]
impl Radium for Cell<i32>
[src]
type Item = i32
pub fn new(value: i32) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut i32
[src]
pub fn into_inner(self) -> i32
[src]
pub fn load(&self, _: Ordering) -> i32
[src]
pub fn store(&self, value: i32, _: Ordering)
[src]
pub fn swap(&self, value: i32, _: Ordering) -> i32
[src]
pub fn compare_and_swap(&self, current: i32, new: i32, _: Ordering) -> i32
[src]
pub fn compare_exchange(
&self,
current: i32,
new: i32,
_: Ordering,
_: Ordering
) -> Result<i32, i32>
[src]
&self,
current: i32,
new: i32,
_: Ordering,
_: Ordering
) -> Result<i32, i32>
pub fn compare_exchange_weak(
&self,
current: i32,
new: i32,
success: Ordering,
failure: Ordering
) -> Result<i32, i32>
[src]
&self,
current: i32,
new: i32,
success: Ordering,
failure: Ordering
) -> Result<i32, i32>
pub fn fetch_and(&self, value: i32, _: Ordering) -> i32
[src]
pub fn fetch_nand(&self, value: i32, _: Ordering) -> i32
[src]
pub fn fetch_or(&self, value: i32, _: Ordering) -> i32
[src]
pub fn fetch_xor(&self, value: i32, _: Ordering) -> i32
[src]
pub fn fetch_add(&self, value: i32, _: Ordering) -> i32
[src]
pub fn fetch_sub(&self, value: i32, _: Ordering) -> i32
[src]
impl Radium for AtomicU32
[src]
type Item = u32
pub fn new(value: u32) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut u32
[src]
pub fn into_inner(self) -> u32
[src]
pub fn load(&self, order: Ordering) -> u32
[src]
pub fn store(&self, value: u32, order: Ordering)
[src]
pub fn swap(&self, value: u32, order: Ordering) -> u32
[src]
pub fn compare_and_swap(&self, current: u32, new: u32, order: Ordering) -> u32
[src]
pub fn compare_exchange(
&self,
current: u32,
new: u32,
success: Ordering,
failure: Ordering
) -> Result<u32, u32>
[src]
&self,
current: u32,
new: u32,
success: Ordering,
failure: Ordering
) -> Result<u32, u32>
pub fn compare_exchange_weak(
&self,
current: u32,
new: u32,
success: Ordering,
failure: Ordering
) -> Result<u32, u32>
[src]
&self,
current: u32,
new: u32,
success: Ordering,
failure: Ordering
) -> Result<u32, u32>
pub fn fetch_and(&self, value: u32, order: Ordering) -> u32
[src]
pub fn fetch_nand(&self, value: u32, order: Ordering) -> u32
[src]
pub fn fetch_or(&self, value: u32, order: Ordering) -> u32
[src]
pub fn fetch_xor(&self, value: u32, order: Ordering) -> u32
[src]
pub fn fetch_add(&self, value: u32, order: Ordering) -> u32
[src]
pub fn fetch_sub(&self, value: u32, order: Ordering) -> u32
[src]
impl Radium for Cell<u32>
[src]
type Item = u32
pub fn new(value: u32) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut u32
[src]
pub fn into_inner(self) -> u32
[src]
pub fn load(&self, _: Ordering) -> u32
[src]
pub fn store(&self, value: u32, _: Ordering)
[src]
pub fn swap(&self, value: u32, _: Ordering) -> u32
[src]
pub fn compare_and_swap(&self, current: u32, new: u32, _: Ordering) -> u32
[src]
pub fn compare_exchange(
&self,
current: u32,
new: u32,
_: Ordering,
_: Ordering
) -> Result<u32, u32>
[src]
&self,
current: u32,
new: u32,
_: Ordering,
_: Ordering
) -> Result<u32, u32>
pub fn compare_exchange_weak(
&self,
current: u32,
new: u32,
success: Ordering,
failure: Ordering
) -> Result<u32, u32>
[src]
&self,
current: u32,
new: u32,
success: Ordering,
failure: Ordering
) -> Result<u32, u32>
pub fn fetch_and(&self, value: u32, _: Ordering) -> u32
[src]
pub fn fetch_nand(&self, value: u32, _: Ordering) -> u32
[src]
pub fn fetch_or(&self, value: u32, _: Ordering) -> u32
[src]
pub fn fetch_xor(&self, value: u32, _: Ordering) -> u32
[src]
pub fn fetch_add(&self, value: u32, _: Ordering) -> u32
[src]
pub fn fetch_sub(&self, value: u32, _: Ordering) -> u32
[src]
impl Radium for AtomicI64
[src]
type Item = i64
pub fn new(value: i64) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut i64
[src]
pub fn into_inner(self) -> i64
[src]
pub fn load(&self, order: Ordering) -> i64
[src]
pub fn store(&self, value: i64, order: Ordering)
[src]
pub fn swap(&self, value: i64, order: Ordering) -> i64
[src]
pub fn compare_and_swap(&self, current: i64, new: i64, order: Ordering) -> i64
[src]
pub fn compare_exchange(
&self,
current: i64,
new: i64,
success: Ordering,
failure: Ordering
) -> Result<i64, i64>
[src]
&self,
current: i64,
new: i64,
success: Ordering,
failure: Ordering
) -> Result<i64, i64>
pub fn compare_exchange_weak(
&self,
current: i64,
new: i64,
success: Ordering,
failure: Ordering
) -> Result<i64, i64>
[src]
&self,
current: i64,
new: i64,
success: Ordering,
failure: Ordering
) -> Result<i64, i64>
pub fn fetch_and(&self, value: i64, order: Ordering) -> i64
[src]
pub fn fetch_nand(&self, value: i64, order: Ordering) -> i64
[src]
pub fn fetch_or(&self, value: i64, order: Ordering) -> i64
[src]
pub fn fetch_xor(&self, value: i64, order: Ordering) -> i64
[src]
pub fn fetch_add(&self, value: i64, order: Ordering) -> i64
[src]
pub fn fetch_sub(&self, value: i64, order: Ordering) -> i64
[src]
impl Radium for Cell<i64>
[src]
type Item = i64
pub fn new(value: i64) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut i64
[src]
pub fn into_inner(self) -> i64
[src]
pub fn load(&self, _: Ordering) -> i64
[src]
pub fn store(&self, value: i64, _: Ordering)
[src]
pub fn swap(&self, value: i64, _: Ordering) -> i64
[src]
pub fn compare_and_swap(&self, current: i64, new: i64, _: Ordering) -> i64
[src]
pub fn compare_exchange(
&self,
current: i64,
new: i64,
_: Ordering,
_: Ordering
) -> Result<i64, i64>
[src]
&self,
current: i64,
new: i64,
_: Ordering,
_: Ordering
) -> Result<i64, i64>
pub fn compare_exchange_weak(
&self,
current: i64,
new: i64,
success: Ordering,
failure: Ordering
) -> Result<i64, i64>
[src]
&self,
current: i64,
new: i64,
success: Ordering,
failure: Ordering
) -> Result<i64, i64>
pub fn fetch_and(&self, value: i64, _: Ordering) -> i64
[src]
pub fn fetch_nand(&self, value: i64, _: Ordering) -> i64
[src]
pub fn fetch_or(&self, value: i64, _: Ordering) -> i64
[src]
pub fn fetch_xor(&self, value: i64, _: Ordering) -> i64
[src]
pub fn fetch_add(&self, value: i64, _: Ordering) -> i64
[src]
pub fn fetch_sub(&self, value: i64, _: Ordering) -> i64
[src]
impl Radium for AtomicU64
[src]
type Item = u64
pub fn new(value: u64) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut u64
[src]
pub fn into_inner(self) -> u64
[src]
pub fn load(&self, order: Ordering) -> u64
[src]
pub fn store(&self, value: u64, order: Ordering)
[src]
pub fn swap(&self, value: u64, order: Ordering) -> u64
[src]
pub fn compare_and_swap(&self, current: u64, new: u64, order: Ordering) -> u64
[src]
pub fn compare_exchange(
&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>
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>
pub fn fetch_and(&self, value: u64, order: Ordering) -> u64
[src]
pub fn fetch_nand(&self, value: u64, order: Ordering) -> u64
[src]
pub fn fetch_or(&self, value: u64, order: Ordering) -> u64
[src]
pub fn fetch_xor(&self, value: u64, order: Ordering) -> u64
[src]
pub fn fetch_add(&self, value: u64, order: Ordering) -> u64
[src]
pub fn fetch_sub(&self, value: u64, order: Ordering) -> u64
[src]
impl Radium for Cell<u64>
[src]
type Item = u64
pub fn new(value: u64) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut u64
[src]
pub fn into_inner(self) -> u64
[src]
pub fn load(&self, _: Ordering) -> u64
[src]
pub fn store(&self, value: u64, _: Ordering)
[src]
pub fn swap(&self, value: u64, _: Ordering) -> u64
[src]
pub fn compare_and_swap(&self, current: u64, new: u64, _: Ordering) -> u64
[src]
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>
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>
pub fn fetch_and(&self, value: u64, _: Ordering) -> u64
[src]
pub fn fetch_nand(&self, value: u64, _: Ordering) -> u64
[src]
pub fn fetch_or(&self, value: u64, _: Ordering) -> u64
[src]
pub fn fetch_xor(&self, value: u64, _: Ordering) -> u64
[src]
pub fn fetch_add(&self, value: u64, _: Ordering) -> u64
[src]
pub fn fetch_sub(&self, value: u64, _: Ordering) -> u64
[src]
impl Radium for AtomicIsize
[src]
type Item = isize
pub fn new(value: isize) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut isize
[src]
pub fn into_inner(self) -> isize
[src]
pub fn load(&self, order: Ordering) -> isize
[src]
pub fn store(&self, value: isize, order: Ordering)
[src]
pub fn swap(&self, value: isize, order: Ordering) -> isize
[src]
pub fn compare_and_swap(
&self,
current: isize,
new: isize,
order: Ordering
) -> isize
[src]
&self,
current: isize,
new: isize,
order: Ordering
) -> isize
pub fn compare_exchange(
&self,
current: isize,
new: isize,
success: Ordering,
failure: Ordering
) -> Result<isize, isize>
[src]
&self,
current: isize,
new: isize,
success: Ordering,
failure: Ordering
) -> Result<isize, isize>
pub fn compare_exchange_weak(
&self,
current: isize,
new: isize,
success: Ordering,
failure: Ordering
) -> Result<isize, isize>
[src]
&self,
current: isize,
new: isize,
success: Ordering,
failure: Ordering
) -> Result<isize, isize>
pub fn fetch_and(&self, value: isize, order: Ordering) -> isize
[src]
pub fn fetch_nand(&self, value: isize, order: Ordering) -> isize
[src]
pub fn fetch_or(&self, value: isize, order: Ordering) -> isize
[src]
pub fn fetch_xor(&self, value: isize, order: Ordering) -> isize
[src]
pub fn fetch_add(&self, value: isize, order: Ordering) -> isize
[src]
pub fn fetch_sub(&self, value: isize, order: Ordering) -> isize
[src]
impl Radium for Cell<isize>
[src]
type Item = isize
pub fn new(value: isize) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut isize
[src]
pub fn into_inner(self) -> isize
[src]
pub fn load(&self, _: Ordering) -> isize
[src]
pub fn store(&self, value: isize, _: Ordering)
[src]
pub fn swap(&self, value: isize, _: Ordering) -> isize
[src]
pub fn compare_and_swap(&self, current: isize, new: isize, _: Ordering) -> isize
[src]
pub fn compare_exchange(
&self,
current: isize,
new: isize,
_: Ordering,
_: Ordering
) -> Result<isize, isize>
[src]
&self,
current: isize,
new: isize,
_: Ordering,
_: Ordering
) -> Result<isize, isize>
pub fn compare_exchange_weak(
&self,
current: isize,
new: isize,
success: Ordering,
failure: Ordering
) -> Result<isize, isize>
[src]
&self,
current: isize,
new: isize,
success: Ordering,
failure: Ordering
) -> Result<isize, isize>
pub fn fetch_and(&self, value: isize, _: Ordering) -> isize
[src]
pub fn fetch_nand(&self, value: isize, _: Ordering) -> isize
[src]
pub fn fetch_or(&self, value: isize, _: Ordering) -> isize
[src]
pub fn fetch_xor(&self, value: isize, _: Ordering) -> isize
[src]
pub fn fetch_add(&self, value: isize, _: Ordering) -> isize
[src]
pub fn fetch_sub(&self, value: isize, _: Ordering) -> isize
[src]
impl Radium for AtomicUsize
[src]
type Item = usize
pub fn new(value: usize) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut usize
[src]
pub fn into_inner(self) -> usize
[src]
pub fn load(&self, order: Ordering) -> usize
[src]
pub fn store(&self, value: usize, order: Ordering)
[src]
pub fn swap(&self, value: usize, order: Ordering) -> usize
[src]
pub fn compare_and_swap(
&self,
current: usize,
new: usize,
order: Ordering
) -> usize
[src]
&self,
current: usize,
new: usize,
order: Ordering
) -> usize
pub fn compare_exchange(
&self,
current: usize,
new: usize,
success: Ordering,
failure: Ordering
) -> Result<usize, usize>
[src]
&self,
current: usize,
new: usize,
success: Ordering,
failure: Ordering
) -> Result<usize, usize>
pub fn compare_exchange_weak(
&self,
current: usize,
new: usize,
success: Ordering,
failure: Ordering
) -> Result<usize, usize>
[src]
&self,
current: usize,
new: usize,
success: Ordering,
failure: Ordering
) -> Result<usize, usize>
pub fn fetch_and(&self, value: usize, order: Ordering) -> usize
[src]
pub fn fetch_nand(&self, value: usize, order: Ordering) -> usize
[src]
pub fn fetch_or(&self, value: usize, order: Ordering) -> usize
[src]
pub fn fetch_xor(&self, value: usize, order: Ordering) -> usize
[src]
pub fn fetch_add(&self, value: usize, order: Ordering) -> usize
[src]
pub fn fetch_sub(&self, value: usize, order: Ordering) -> usize
[src]
impl Radium for Cell<usize>
[src]
type Item = usize
pub fn new(value: usize) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut usize
[src]
pub fn into_inner(self) -> usize
[src]
pub fn load(&self, _: Ordering) -> usize
[src]
pub fn store(&self, value: usize, _: Ordering)
[src]
pub fn swap(&self, value: usize, _: Ordering) -> usize
[src]
pub fn compare_and_swap(&self, current: usize, new: usize, _: Ordering) -> usize
[src]
pub fn compare_exchange(
&self,
current: usize,
new: usize,
_: Ordering,
_: Ordering
) -> Result<usize, usize>
[src]
&self,
current: usize,
new: usize,
_: Ordering,
_: Ordering
) -> Result<usize, usize>
pub fn compare_exchange_weak(
&self,
current: usize,
new: usize,
success: Ordering,
failure: Ordering
) -> Result<usize, usize>
[src]
&self,
current: usize,
new: usize,
success: Ordering,
failure: Ordering
) -> Result<usize, usize>
pub fn fetch_and(&self, value: usize, _: Ordering) -> usize
[src]
pub fn fetch_nand(&self, value: usize, _: Ordering) -> usize
[src]
pub fn fetch_or(&self, value: usize, _: Ordering) -> usize
[src]
pub fn fetch_xor(&self, value: usize, _: Ordering) -> usize
[src]
pub fn fetch_add(&self, value: usize, _: Ordering) -> usize
[src]
pub fn fetch_sub(&self, value: usize, _: Ordering) -> usize
[src]
impl Radium for AtomicBool
[src]
type Item = bool
pub fn new(value: bool) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut bool
[src]
pub fn into_inner(self) -> bool
[src]
pub fn load(&self, order: Ordering) -> bool
[src]
pub fn store(&self, value: bool, order: Ordering)
[src]
pub fn swap(&self, value: bool, order: Ordering) -> bool
[src]
pub fn compare_and_swap(
&self,
current: bool,
new: bool,
order: Ordering
) -> bool
[src]
&self,
current: bool,
new: bool,
order: Ordering
) -> bool
pub fn compare_exchange(
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering
) -> Result<bool, bool>
[src]
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering
) -> Result<bool, bool>
pub fn compare_exchange_weak(
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering
) -> Result<bool, bool>
[src]
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering
) -> Result<bool, bool>
pub fn fetch_and(&self, value: bool, order: Ordering) -> bool
[src]
pub fn fetch_nand(&self, value: bool, order: Ordering) -> bool
[src]
pub fn fetch_or(&self, value: bool, order: Ordering) -> bool
[src]
pub fn fetch_xor(&self, value: bool, order: Ordering) -> bool
[src]
impl Radium for Cell<bool>
[src]
type Item = bool
pub fn new(value: bool) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut bool
[src]
pub fn into_inner(self) -> bool
[src]
pub fn load(&self, _: Ordering) -> bool
[src]
pub fn store(&self, value: bool, _: Ordering)
[src]
pub fn swap(&self, value: bool, _: Ordering) -> bool
[src]
pub fn compare_and_swap(&self, current: bool, new: bool, _: Ordering) -> bool
[src]
pub fn compare_exchange(
&self,
current: bool,
new: bool,
_: Ordering,
_: Ordering
) -> Result<bool, bool>
[src]
&self,
current: bool,
new: bool,
_: Ordering,
_: Ordering
) -> Result<bool, bool>
pub fn compare_exchange_weak(
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering
) -> Result<bool, bool>
[src]
&self,
current: bool,
new: bool,
success: Ordering,
failure: Ordering
) -> Result<bool, bool>
pub fn fetch_and(&self, value: bool, _: Ordering) -> bool
[src]
pub fn fetch_nand(&self, value: bool, _: Ordering) -> bool
[src]
pub fn fetch_or(&self, value: bool, _: Ordering) -> bool
[src]
pub fn fetch_xor(&self, value: bool, _: Ordering) -> bool
[src]
impl<T> Radium for AtomicPtr<T>
[src]
type Item = *mut T
pub fn new(value: *mut T) -> Self
[src]
pub fn fence(order: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut *mut T
[src]
pub fn into_inner(self) -> *mut T
[src]
pub fn load(&self, order: Ordering) -> *mut T
[src]
pub fn store(&self, value: *mut T, order: Ordering)
[src]
pub fn swap(&self, value: *mut T, order: Ordering) -> *mut T
[src]
pub fn compare_and_swap(
&self,
current: *mut T,
new: *mut T,
order: Ordering
) -> *mut T
[src]
&self,
current: *mut T,
new: *mut T,
order: Ordering
) -> *mut T
pub fn compare_exchange(
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>
[src]
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>
pub fn compare_exchange_weak(
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>
[src]
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>
impl<T> Radium for Cell<*mut T>
[src]
type Item = *mut T
pub fn new(value: *mut T) -> Self
[src]
pub fn fence(_: Ordering)
[src]
pub fn get_mut(&mut self) -> &mut *mut T
[src]
pub fn into_inner(self) -> *mut T
[src]
pub fn load(&self, _: Ordering) -> *mut T
[src]
pub fn store(&self, value: *mut T, _: Ordering)
[src]
pub fn swap(&self, value: *mut T, _: Ordering) -> *mut T
[src]
pub fn compare_and_swap(
&self,
current: *mut T,
new: *mut T,
_: Ordering
) -> *mut T
[src]
&self,
current: *mut T,
new: *mut T,
_: Ordering
) -> *mut T
pub fn compare_exchange(
&self,
current: *mut T,
new: *mut T,
_: Ordering,
_: Ordering
) -> Result<*mut T, *mut T>
[src]
&self,
current: *mut T,
new: *mut T,
_: Ordering,
_: Ordering
) -> Result<*mut T, *mut T>
pub fn compare_exchange_weak(
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>
[src]
&self,
current: *mut T,
new: *mut T,
success: Ordering,
failure: Ordering
) -> Result<*mut T, *mut T>