Trait atomic_types::Atomic

pub trait Atomic<T>: Send + Sync + Sized where
    T: Sized, {
    fn new(val: T) -> Self;
    fn store(&self, val: T, order: Ordering);
    fn load(&self, order: Ordering) -> T;
    fn swap(&self, val: T, order: Ordering) -> T;
    fn get_mut(&mut self) -> &mut T;
    fn into_inner(self) -> T;
    fn compare_and_swap(&self, current: T, new: T, order: Ordering) -> T;
    fn compare_exchange(
        &self, 
        current: T, 
        new: T, 
        success: Ordering, 
        failure: Ordering
    ) -> Result<T, T>;
    fn compare_exchange_weak(
        &self, 
        current: T, 
        new: T, 
        success: Ordering, 
        failure: Ordering
    ) -> Result<T, T>;

    unsafe fn from_raw(val: &T) -> &Self { ... }
}

Trait describing an atomic version of an atomically-sized type.

Required methods

fn new(val: T) -> Self

fn store(&self, val: T, order: Ordering)

fn load(&self, order: Ordering) -> T

fn swap(&self, val: T, order: Ordering) -> T

fn get_mut(&mut self) -> &mut T

fn into_inner(self) -> T

fn compare_and_swap(&self, current: T, new: T, order: Ordering) -> T

fn compare_exchange(
    &self,
    current: T,
    new: T,
    success: Ordering,
    failure: Ordering
) -> Result<T, T>

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

Loading content...

Provided methods

unsafe fn from_raw(val: &T) -> &Self

Generate a reference to the atomic version of this type using its normal version.

Loading content...

Implementations on Foreign Types

impl Atomic<usize> for AtomicUsize

fn new(val: usize) -> Self

fn store(&self, val: usize, order: Ordering)

fn load(&self, order: Ordering) -> usize

fn swap(&self, val: usize, order: Ordering) -> usize

fn get_mut(&mut self) -> &mut usize

fn into_inner(self) -> usize

fn compare_and_swap(&self, current: usize, new: usize, order: Ordering) -> usize

fn compare_exchange(
    &self,
    current: usize,
    new: usize,
    success: Ordering,
    failure: Ordering
) -> Result<usize, usize>

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<isize> for AtomicIsize

fn new(val: isize) -> Self

fn store(&self, val: isize, order: Ordering)

fn load(&self, order: Ordering) -> isize

fn swap(&self, val: isize, order: Ordering) -> isize

fn get_mut(&mut self) -> &mut isize

fn into_inner(self) -> isize

fn compare_and_swap(&self, current: isize, new: isize, order: Ordering) -> isize

fn compare_exchange(
    &self,
    current: isize,
    new: isize,
    success: Ordering,
    failure: Ordering
) -> Result<isize, isize>

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<u64> for AtomicU64

fn new(val: u64) -> Self

fn store(&self, val: u64, order: Ordering)

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

fn swap(&self, val: u64, order: Ordering) -> u64

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

fn into_inner(self) -> u64

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

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

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<i64> for AtomicI64

fn new(val: i64) -> Self

fn store(&self, val: i64, order: Ordering)

fn load(&self, order: Ordering) -> i64

fn swap(&self, val: i64, order: Ordering) -> i64

fn get_mut(&mut self) -> &mut i64

fn into_inner(self) -> i64

fn compare_and_swap(&self, current: i64, new: i64, order: Ordering) -> i64

fn compare_exchange(
    &self,
    current: i64,
    new: i64,
    success: Ordering,
    failure: Ordering
) -> Result<i64, i64>

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<u32> for AtomicU32

fn new(val: u32) -> Self

fn store(&self, val: u32, order: Ordering)

fn load(&self, order: Ordering) -> u32

fn swap(&self, val: u32, order: Ordering) -> u32

fn get_mut(&mut self) -> &mut u32

fn into_inner(self) -> u32

fn compare_and_swap(&self, current: u32, new: u32, order: Ordering) -> u32

fn compare_exchange(
    &self,
    current: u32,
    new: u32,
    success: Ordering,
    failure: Ordering
) -> Result<u32, u32>

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<i32> for AtomicI32

fn new(val: i32) -> Self

fn store(&self, val: i32, order: Ordering)

fn load(&self, order: Ordering) -> i32

fn swap(&self, val: i32, order: Ordering) -> i32

fn get_mut(&mut self) -> &mut i32

fn into_inner(self) -> i32

fn compare_and_swap(&self, current: i32, new: i32, order: Ordering) -> i32

fn compare_exchange(
    &self,
    current: i32,
    new: i32,
    success: Ordering,
    failure: Ordering
) -> Result<i32, i32>

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<u16> for AtomicU16

fn new(val: u16) -> Self

fn store(&self, val: u16, order: Ordering)

fn load(&self, order: Ordering) -> u16

fn swap(&self, val: u16, order: Ordering) -> u16

fn get_mut(&mut self) -> &mut u16

fn into_inner(self) -> u16

fn compare_and_swap(&self, current: u16, new: u16, order: Ordering) -> u16

fn compare_exchange(
    &self,
    current: u16,
    new: u16,
    success: Ordering,
    failure: Ordering
) -> Result<u16, u16>

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<i16> for AtomicI16

fn new(val: i16) -> Self

fn store(&self, val: i16, order: Ordering)

fn load(&self, order: Ordering) -> i16

fn swap(&self, val: i16, order: Ordering) -> i16

fn get_mut(&mut self) -> &mut i16

fn into_inner(self) -> i16

fn compare_and_swap(&self, current: i16, new: i16, order: Ordering) -> i16

fn compare_exchange(
    &self,
    current: i16,
    new: i16,
    success: Ordering,
    failure: Ordering
) -> Result<i16, i16>

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<u8> for AtomicU8

fn new(val: u8) -> Self

fn store(&self, val: u8, order: Ordering)

fn load(&self, order: Ordering) -> u8

fn swap(&self, val: u8, order: Ordering) -> u8

fn get_mut(&mut self) -> &mut u8

fn into_inner(self) -> u8

fn compare_and_swap(&self, current: u8, new: u8, order: Ordering) -> u8

fn compare_exchange(
    &self,
    current: u8,
    new: u8,
    success: Ordering,
    failure: Ordering
) -> Result<u8, u8>

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<i8> for AtomicI8

fn new(val: i8) -> Self

fn store(&self, val: i8, order: Ordering)

fn load(&self, order: Ordering) -> i8

fn swap(&self, val: i8, order: Ordering) -> i8

fn get_mut(&mut self) -> &mut i8

fn into_inner(self) -> i8

fn compare_and_swap(&self, current: i8, new: i8, order: Ordering) -> i8

fn compare_exchange(
    &self,
    current: i8,
    new: i8,
    success: Ordering,
    failure: Ordering
) -> Result<i8, i8>

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

unsafe fn from_raw(val: &T) -> &Self

impl Atomic<bool> for AtomicBool

fn new(val: bool) -> Self

fn store(&self, val: bool, order: Ordering)

fn load(&self, order: Ordering) -> bool

fn swap(&self, val: bool, order: Ordering) -> bool

fn get_mut(&mut self) -> &mut bool

fn into_inner(self) -> bool

fn compare_and_swap(&self, current: bool, new: bool, order: Ordering) -> bool

fn compare_exchange(
    &self,
    current: bool,
    new: bool,
    success: Ordering,
    failure: Ordering
) -> Result<bool, bool>

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

unsafe fn from_raw(val: &T) -> &Self

impl<T> Atomic<*mut T> for AtomicPtr<T>

fn new(val: *mut T) -> Self

fn store(&self, val: *mut T, order: Ordering)

fn load(&self, order: Ordering) -> *mut T

fn swap(&self, val: *mut T, order: Ordering) -> *mut T

fn get_mut(&mut self) -> &mut *mut T

fn into_inner(self) -> *mut T

fn compare_and_swap(
    &self,
    current: *mut T,
    new: *mut T,
    order: Ordering
) -> *mut T

fn compare_exchange(
    &self,
    current: *mut T,
    new: *mut T,
    success: Ordering,
    failure: Ordering
) -> Result<*mut T, *mut T>

fn compare_exchange_weak(
    &self,
    current: *mut T,
    new: *mut T,
    success: Ordering,
    failure: Ordering
) -> Result<*mut T, *mut T>

unsafe fn from_raw(val: &T) -> &Self

Loading content...

Implementors

Loading content...