Struct atomic_value::AtomicValue

pub struct AtomicValue<T> { /* fields omitted */ }

A wrapper provides an atomic load and store of a value.

You can use load to get the current value which is wrapped by Arc, or use store to set a new value atomically.

Example

use atomic_value::AtomicValue;

let value = AtomicValue::new(10);

assert_eq!(*value.load(), 10);

Implementations

impl<T> AtomicValue<T>

pub fn new(value: T) -> Self

Create an AtomicValue with provide value.

Example

use atomic_value::AtomicValue;

let value = AtomicValue::new(100);

pub fn load(&self) -> Arc<T>

Load current value atomically.

This function will return a value which wrapped by an Arc. After get the value, it won’t be effect by store, swap or compare_and_swap.

Example

use atomic_value::AtomicValue;

let value = AtomicValue::new(10);

assert_eq!(*value.load(), 10);

pub fn store(&self, new_value: T)

Store a new value atomically.

The new value won’t change any loaded value. This method like swap but won’t return old value.

Example

use atomic_value::AtomicValue;

let value = AtomicValue::new(10);

let old = value.load();

assert_eq!(*old, 10);

value.store(100);

assert_eq!(*value.load(), 100);

pub fn swap(&self, new_value: T) -> Arc<T>

Store a new value into AtomicValue, and return the old value with Arc wrapping.

The new value won’t change any loaded value. This method like store but will return old value.

Example

use atomic_value::AtomicValue;

let value = AtomicValue::new(10);

let old = value.load();

assert_eq!(*old, 10);

let old = value.swap(100);

assert_eq!(*old ,10);

assert_eq!(*value.load(), 100);

pub fn compare_exchange(
    &self,
    current: &T,
    new_value: T,
    success: Ordering,
    failure: Ordering
) -> Result<Arc<T>, Error<T>> where
    T: PartialEq, 

Stores a value into the AtomicValue if the current value is the same as the current value.

The new value won’t change any loaded values.

Example

use atomic_value::{AtomicValue, Error};
use std::sync::atomic::Ordering;

let value = AtomicValue::new(10);

let result = value.compare_exchange(&10, 20, Ordering::AcqRel, Ordering::Acquire);
assert_eq!(*result.unwrap(), 10);

let result = value.compare_exchange(&10, 30, Ordering::AcqRel, Ordering::Acquire);
let Error(current, new_value) = result.unwrap_err();

assert_eq!(*current, 20);
assert_eq!(new_value, 30);

Trait Implementations

impl<T: Debug> Debug for AtomicValue<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Send + Sync> Sync for AtomicValue<T>