Struct bitcoin_proxy::NAME_LOOKUP
source · pub struct NAME_LOOKUP { /* private fields */ }Methods from Deref<Target = Atomic<bool>>§
pub fn load(&self, order: Ordering) -> T
pub fn load(&self, order: Ordering) -> T
Loads a value from the Atomic.
load takes an Ordering argument which describes the memory ordering
of this operation.
Panics
Panics if order is Release or AcqRel.
pub fn store(&self, val: T, order: Ordering)
pub fn store(&self, val: T, order: Ordering)
Stores a value into the Atomic.
store takes an Ordering argument which describes the memory ordering
of this operation.
Panics
Panics if order is Acquire or AcqRel.
pub fn swap(&self, val: T, order: Ordering) -> T
pub fn swap(&self, val: T, order: Ordering) -> T
Stores a value into the Atomic, returning the old value.
swap takes an Ordering argument which describes the memory ordering
of this operation.
pub fn compare_exchange(
&self,
current: T,
new: T,
success: Ordering,
failure: Ordering
) -> Result<T, T>
pub fn compare_exchange(
&self,
current: T,
new: T,
success: Ordering,
failure: Ordering
) -> Result<T, T>
Stores a value into the Atomic 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 new.
compare_exchange takes two Ordering arguments to describe the memory
ordering of this operation. The first describes the required ordering if
the operation succeeds while the second describes the required ordering
when the operation fails. The failure ordering can’t be Release or
AcqRel and must be equivalent or weaker than the success ordering.
pub fn compare_exchange_weak(
&self,
current: T,
new: T,
success: Ordering,
failure: Ordering
) -> Result<T, T>
pub fn compare_exchange_weak(
&self,
current: T,
new: T,
success: Ordering,
failure: Ordering
) -> Result<T, T>
Stores a value into the Atomic if the current 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 previous value.
compare_exchange takes two Ordering arguments to describe the memory
ordering of this operation. The first describes the required ordering if
the operation succeeds while the second describes the required ordering
when the operation fails. The failure ordering can’t be Release or
AcqRel and must be equivalent or weaker than the success ordering.
success ordering.
pub fn fetch_update<F>(
&self,
set_order: Ordering,
fetch_order: Ordering,
f: F
) -> Result<T, T>where
F: FnMut(T) -> Option<T>,
pub fn fetch_update<F>(
&self,
set_order: Ordering,
fetch_order: Ordering,
f: F
) -> Result<T, T>where
F: FnMut(T) -> Option<T>,
Fetches the value, and applies a function to it that returns an optional
new value. Returns a Result of Ok(previous_value) if the function returned Some(_), else
Err(previous_value).
Note: This may call the function multiple times if the value has been changed from other threads in
the meantime, as long as the function returns Some(_), but the function will have been applied
only once to the stored value.
fetch_update takes two Ordering arguments to describe the memory ordering of this operation.
The first describes the required ordering for when the operation finally succeeds while the second
describes the required ordering for loads. These correspond to the success and failure orderings of
compare_exchange respectively.
Using Acquire as success ordering makes the store part
of this operation Relaxed, and using Release makes the final successful load
Relaxed. The (failed) load ordering can only be SeqCst, Acquire or Relaxed
and must be equivalent to or weaker than the success ordering.
Examples
use atomic::{Atomic, Ordering};
let x = Atomic::new(7);
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |_| None), Err(7));
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(7));
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(8));
assert_eq!(x.load(Ordering::SeqCst), 9);pub fn fetch_and(&self, val: bool, order: Ordering) -> bool
pub fn fetch_and(&self, val: bool, order: Ordering) -> bool
Logical “and” with a boolean value.
Performs a logical “and” operation on the current value and the argument
val, and sets the new value to the result.
Returns the previous value.
pub fn fetch_add(&self, val: i8, order: Ordering) -> i8
pub fn fetch_add(&self, val: i8, order: Ordering) -> i8
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: i8, order: Ordering) -> i8
pub fn fetch_sub(&self, val: i8, order: Ordering) -> i8
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: i8, order: Ordering) -> i8
pub fn fetch_and(&self, val: i8, order: Ordering) -> i8
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: i16, order: Ordering) -> i16
pub fn fetch_add(&self, val: i16, order: Ordering) -> i16
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: i16, order: Ordering) -> i16
pub fn fetch_sub(&self, val: i16, order: Ordering) -> i16
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: i16, order: Ordering) -> i16
pub fn fetch_and(&self, val: i16, order: Ordering) -> i16
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: i32, order: Ordering) -> i32
pub fn fetch_add(&self, val: i32, order: Ordering) -> i32
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: i32, order: Ordering) -> i32
pub fn fetch_sub(&self, val: i32, order: Ordering) -> i32
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: i32, order: Ordering) -> i32
pub fn fetch_and(&self, val: i32, order: Ordering) -> i32
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: i64, order: Ordering) -> i64
pub fn fetch_add(&self, val: i64, order: Ordering) -> i64
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: i64, order: Ordering) -> i64
pub fn fetch_sub(&self, val: i64, order: Ordering) -> i64
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: i64, order: Ordering) -> i64
pub fn fetch_and(&self, val: i64, order: Ordering) -> i64
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: isize, order: Ordering) -> isize
pub fn fetch_add(&self, val: isize, order: Ordering) -> isize
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: isize, order: Ordering) -> isize
pub fn fetch_sub(&self, val: isize, order: Ordering) -> isize
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: isize, order: Ordering) -> isize
pub fn fetch_and(&self, val: isize, order: Ordering) -> isize
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: i128, order: Ordering) -> i128
pub fn fetch_add(&self, val: i128, order: Ordering) -> i128
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: i128, order: Ordering) -> i128
pub fn fetch_sub(&self, val: i128, order: Ordering) -> i128
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: i128, order: Ordering) -> i128
pub fn fetch_and(&self, val: i128, order: Ordering) -> i128
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: u8, order: Ordering) -> u8
pub fn fetch_add(&self, val: u8, order: Ordering) -> u8
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: u8, order: Ordering) -> u8
pub fn fetch_sub(&self, val: u8, order: Ordering) -> u8
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: u8, order: Ordering) -> u8
pub fn fetch_and(&self, val: u8, order: Ordering) -> u8
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: u16, order: Ordering) -> u16
pub fn fetch_add(&self, val: u16, order: Ordering) -> u16
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: u16, order: Ordering) -> u16
pub fn fetch_sub(&self, val: u16, order: Ordering) -> u16
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: u16, order: Ordering) -> u16
pub fn fetch_and(&self, val: u16, order: Ordering) -> u16
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: u32, order: Ordering) -> u32
pub fn fetch_add(&self, val: u32, order: Ordering) -> u32
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: u32, order: Ordering) -> u32
pub fn fetch_sub(&self, val: u32, order: Ordering) -> u32
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: u32, order: Ordering) -> u32
pub fn fetch_and(&self, val: u32, order: Ordering) -> u32
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: u64, order: Ordering) -> u64
pub fn fetch_add(&self, val: u64, order: Ordering) -> u64
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: u64, order: Ordering) -> u64
pub fn fetch_sub(&self, val: u64, order: Ordering) -> u64
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: u64, order: Ordering) -> u64
pub fn fetch_and(&self, val: u64, order: Ordering) -> u64
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: usize, order: Ordering) -> usize
pub fn fetch_add(&self, val: usize, order: Ordering) -> usize
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: usize, order: Ordering) -> usize
pub fn fetch_sub(&self, val: usize, order: Ordering) -> usize
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: usize, order: Ordering) -> usize
pub fn fetch_and(&self, val: usize, order: Ordering) -> usize
Bitwise and with the current value, returning the previous value.
pub fn fetch_add(&self, val: u128, order: Ordering) -> u128
pub fn fetch_add(&self, val: u128, order: Ordering) -> u128
Add to the current value, returning the previous value.
pub fn fetch_sub(&self, val: u128, order: Ordering) -> u128
pub fn fetch_sub(&self, val: u128, order: Ordering) -> u128
Subtract from the current value, returning the previous value.
pub fn fetch_and(&self, val: u128, order: Ordering) -> u128
pub fn fetch_and(&self, val: u128, order: Ordering) -> u128
Bitwise and with the current value, returning the previous value.