Trait atomic_prim_traits::AtomicInt

pub trait AtomicInt: Default + Send + Sync + RefUnwindSafe + UnwindSafe {
    type Prim: Sized + Eq + Ord;
    fn new(val: Self::Prim) -> Self;
    fn fetch_add(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim;
    fn fetch_sub(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim;
    fn fetch_and(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim;
    fn fetch_nand(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim;
    fn fetch_or(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim;
    fn fetch_xor(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim;
    fn get_mut(&mut self) -> &mut Self::Prim;
    fn into_inner(self) -> Self::Prim;
    fn load(&self, order: Ordering) -> Self::Prim;
    fn store(&self, val: Self::Prim, order: Ordering);
    fn swap(&self, val: Self::Prim, order: Ordering) -> Self::Prim;
    fn compare_and_swap(
        &self, 
        current: Self::Prim, 
        new: Self::Prim, 
        ordering: Ordering
    ) -> Self::Prim;
    fn compare_exchange(
        &self, 
        current: Self::Prim, 
        new: Self::Prim, 
        success: Ordering, 
        failure: Ordering
    ) -> Result<Self::Prim, Self::Prim>;
    fn compare_exchange_weak(
        &self, 
        current: Self::Prim, 
        new: Self::Prim, 
        success: Ordering, 
        failure: Ordering
    ) -> Result<Self::Prim, Self::Prim>;
}

Associated Types

type Prim: Sized + Eq + Ord

Loading content...

Required methods

fn new(val: Self::Prim) -> Self

fn fetch_add(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim

fn fetch_sub(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim

fn fetch_and(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim

fn fetch_nand(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim

fn fetch_or(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim

fn fetch_xor(&self, new: Self::Prim, ordering: Ordering) -> Self::Prim

fn get_mut(&mut self) -> &mut Self::Prim

fn into_inner(self) -> Self::Prim

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

fn store(&self, val: Self::Prim, order: Ordering)

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

fn compare_and_swap(
    &self,
    current: Self::Prim,
    new: Self::Prim,
    ordering: Ordering
) -> Self::Prim

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

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

Loading content...

Implementations on Foreign Types

impl AtomicInt for AtomicU8

type Prim = u8

fn new(val: u8) -> Self

fn fetch_add(&self, new: u8, ordering: Ordering) -> u8

fn fetch_sub(&self, new: u8, ordering: Ordering) -> u8

fn fetch_and(&self, new: u8, ordering: Ordering) -> u8

fn fetch_nand(&self, new: u8, ordering: Ordering) -> u8

fn fetch_or(&self, new: u8, ordering: Ordering) -> u8

fn fetch_xor(&self, new: u8, ordering: Ordering) -> u8

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

fn into_inner(self) -> u8

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

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

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

fn compare_and_swap(&self, current: u8, new: u8, ordering: 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>

impl AtomicInt for AtomicU16

type Prim = u16

fn new(val: u16) -> Self

fn fetch_add(&self, new: u16, ordering: Ordering) -> u16

fn fetch_sub(&self, new: u16, ordering: Ordering) -> u16

fn fetch_and(&self, new: u16, ordering: Ordering) -> u16

fn fetch_nand(&self, new: u16, ordering: Ordering) -> u16

fn fetch_or(&self, new: u16, ordering: Ordering) -> u16

fn fetch_xor(&self, new: u16, ordering: Ordering) -> u16

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

fn into_inner(self) -> u16

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

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

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

fn compare_and_swap(&self, current: u16, new: u16, ordering: 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>

impl AtomicInt for AtomicU32

type Prim = u32

fn new(val: u32) -> Self

fn fetch_add(&self, new: u32, ordering: Ordering) -> u32

fn fetch_sub(&self, new: u32, ordering: Ordering) -> u32

fn fetch_and(&self, new: u32, ordering: Ordering) -> u32

fn fetch_nand(&self, new: u32, ordering: Ordering) -> u32

fn fetch_or(&self, new: u32, ordering: Ordering) -> u32

fn fetch_xor(&self, new: u32, ordering: Ordering) -> u32

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

fn into_inner(self) -> u32

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

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

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

fn compare_and_swap(&self, current: u32, new: u32, ordering: 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>

impl AtomicInt for AtomicU64

type Prim = u64

fn new(val: u64) -> Self

fn fetch_add(&self, new: u64, ordering: Ordering) -> u64

fn fetch_sub(&self, new: u64, ordering: Ordering) -> u64

fn fetch_and(&self, new: u64, ordering: Ordering) -> u64

fn fetch_nand(&self, new: u64, ordering: Ordering) -> u64

fn fetch_or(&self, new: u64, ordering: Ordering) -> u64

fn fetch_xor(&self, new: u64, ordering: Ordering) -> u64

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

fn into_inner(self) -> u64

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

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

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

fn compare_and_swap(&self, current: u64, new: u64, ordering: 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>

impl AtomicInt for AtomicUsize

type Prim = usize

fn new(val: usize) -> Self

fn fetch_add(&self, new: usize, ordering: Ordering) -> usize

fn fetch_sub(&self, new: usize, ordering: Ordering) -> usize

fn fetch_and(&self, new: usize, ordering: Ordering) -> usize

fn fetch_nand(&self, new: usize, ordering: Ordering) -> usize

fn fetch_or(&self, new: usize, ordering: Ordering) -> usize

fn fetch_xor(&self, new: usize, ordering: Ordering) -> usize

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

fn into_inner(self) -> usize

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

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

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

fn compare_and_swap(
    &self,
    current: usize,
    new: usize,
    ordering: 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>

Loading content...

Implementors

Loading content...