| //! `radium` provides a series of helpers for a uniform API over both atomic |
| //! types like [`AtomicUsize`], and non-atomic types like [`Cell<T>`]. |
| //! |
| //! This crate is `#![no_std]`-compatible, and uses no non-core types. |
| //! |
| //! For details, see the documentation for [`Radium`]. |
| //! |
| //! The `types` module provides type names that are atomic where the target |
| //! supports it, and fall back to `Cell` when the target does not. |
| //! |
| //! The `if_atomic!` macro provides a means of conditional compilation based on |
| //! the presence of atomic instructions. It is a substitute for the |
| //! `cfg(target_has_atomic)` or `cfg(accessible)` attribute tests, which are not |
| //! yet stabilized. |
| //! |
| //! --- |
| //! |
| //! **@kneecaw** - <https://twitter.com/kneecaw/status/1132695060812849154> |
| //! > Feelin' lazy: Has someone already written a helper trait abstracting |
| //! > operations over `AtomicUsize` and `Cell<usize>` for generic code which may |
| //! > not care about atomicity? |
| //! |
| //! **@ManishEarth** - <https://twitter.com/ManishEarth/status/1132706585300496384> |
| //! > no but call the crate radium |
| //! > |
| //! > (since people didn't care that it was radioactive and used it in everything) |
| //! |
| //! [`AtomicUsize`]: core::sync::atomic::AtomicUsize |
| //! [`Cell<T>`]: core::cell::Cell |
| |
| #![no_std] |
| #![deny(unconditional_recursion)] |
| |
| #[macro_use] |
| mod macros; |
| |
| pub mod types; |
| |
| use core::cell::Cell; |
| use core::sync::atomic::Ordering; |
| |
| if_atomic! { |
| if atomic(8) { |
| use core::sync::atomic::{AtomicBool, AtomicI8, AtomicU8}; |
| } |
| if atomic(16) { |
| use core::sync::atomic::{AtomicI16, AtomicU16}; |
| } |
| if atomic(32) { |
| use core::sync::atomic::{AtomicI32, AtomicU32}; |
| } |
| if atomic(64) { |
| use core::sync::atomic::{AtomicI64, AtomicU64}; |
| } |
| if atomic(ptr) { |
| use core::sync::atomic::{AtomicIsize, AtomicPtr, AtomicUsize}; |
| } |
| } |
| |
| /// 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. |
| /// |
| /// [atomic wrapper]: core::sync::atomic |
| /// [`Cell<T>`]: core::cell::Cell |
| pub trait Radium { |
| type Item; |
| /// Creates a new value of this type. |
| fn new(value: Self::Item) -> Self; |
| |
| /// If the underlying value is atomic, calls [`fence`] with the given |
| /// [`Ordering`]. Otherwise, does nothing. |
| /// |
| /// [`Ordering`]: core::sync::atomic::Ordering |
| /// [`fence`]: core::sync::atomic::fence |
| fn fence(order: Ordering); |
| |
| /// 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. |
| fn get_mut(&mut self) -> &mut Self::Item; |
| |
| /// Consumes the wrapper and returns the contained value. |
| /// |
| /// This is safe as passing by value ensures no other references exist. |
| fn into_inner(self) -> Self::Item; |
| |
| /// Load a value from this object. |
| /// |
| /// Ordering values are ignored by non-atomic types. |
| /// |
| /// See also: [`AtomicUsize::load`]. |
| /// |
| /// [`AtomicUsize::load`]: core::sync::atomic::AtomicUsize::load |
| fn load(&self, order: Ordering) -> Self::Item; |
| |
| /// Store a value in this object. |
| /// |
| /// Ordering arguments are ignored by non-atomic types. |
| /// |
| /// See also: [`AtomicUsize::store`]. |
| /// |
| /// [`AtomicUsize::store`]: core::sync::atomic::AtomicUsize::store |
| fn store(&self, value: Self::Item, order: Ordering); |
| |
| /// Swap with the value stored in this object. |
| /// |
| /// Ordering arguments are ignored by non-atomic types. |
| /// |
| /// See also: [`AtomicUsize::swap`]. |
| /// |
| /// [`AtomicUsize::swap`]: core::sync::atomic::AtomicUsize::swap |
| fn swap(&self, value: 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`]. |
| /// |
| /// [`AtomicUsize::compare_and_swap`]: core::sync::atomic::AtomicUsize::compare_and_swap |
| #[deprecated = "Use `compare_exchange` or `compare_exchange_weak` instead"] |
| fn compare_and_swap(&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 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`]. |
| /// |
| /// [`AtomicUsize::compare_exchange`]: core::sync::atomic::AtomicUsize::compare_exchange |
| fn compare_exchange( |
| &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`]. |
| /// |
| /// [`AtomicUsize::compare_exchange_weak`]: core::sync::atomic::AtomicUsize::compare_exchange_weak |
| fn compare_exchange_weak( |
| &self, |
| current: Self::Item, |
| new: Self::Item, |
| success: Ordering, |
| failure: Ordering, |
| ) -> Result<Self::Item, Self::Item>; |
| |
| /// 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`]. |
| /// |
| /// [`AtomicUsize::fetch_and`]: core::sync::atomic::AtomicUsize::fetch_and |
| fn fetch_and(&self, value: Self::Item, order: Ordering) -> Self::Item |
| where |
| Self::Item: marker::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`]. |
| /// |
| /// [`AtomicUsize::fetch_nand`]: core::sync::atomic::AtomicUsize::fetch_nand |
| fn fetch_nand(&self, value: Self::Item, order: Ordering) -> Self::Item |
| where |
| Self::Item: marker::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`]. |
| /// |
| /// [`AtomicUsize::fetch_or`]: core::sync::atomic::AtomicUsize::fetch_or |
| fn fetch_or(&self, value: Self::Item, order: Ordering) -> Self::Item |
| where |
| Self::Item: marker::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`]. |
| /// |
| /// [`AtomicUsize::fetch_xor`]: core::sync::atomic::AtomicUsize::fetch_xor |
| fn fetch_xor(&self, value: Self::Item, order: Ordering) -> Self::Item |
| where |
| Self::Item: marker::BitOps; |
| |
| /// 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`]. |
| /// |
| /// [`AtomicUsize::fetch_add`]: core::sync::atomic::AtomicUsize::fetch_add |
| fn fetch_add(&self, value: Self::Item, order: Ordering) -> Self::Item |
| where |
| Self::Item: marker::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`]. |
| /// |
| /// [`AtomicUsize::fetch_sub`]: core::sync::atomic::AtomicUsize::fetch_sub |
| fn fetch_sub(&self, value: Self::Item, order: Ordering) -> Self::Item |
| where |
| Self::Item: marker::NumericOps; |
| |
| /// Fetches the value, and applies a function to it that returns an |
| /// optional new 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. |
| /// |
| /// Returns a `Result` of `Ok(previous_value)` if the function returned |
| /// `Some(_)`, else `Err(previous_value)`. |
| /// |
| /// Ordering arguments are ignored by non-atomic types. |
| /// |
| /// See also: [`AtomicUsize::fetch_update`]. |
| /// |
| /// [`AtomicUsize::fetch_update`]: core::sync::atomic::AtomicUsize::fetch_update |
| fn fetch_update<F>( |
| &self, |
| set_order: Ordering, |
| fetch_order: Ordering, |
| f: F, |
| ) -> Result<Self::Item, Self::Item> |
| where |
| F: FnMut(Self::Item) -> Option<Self::Item>; |
| } |
| |
| /// Marker traits used by [`Radium`]. |
| pub mod marker { |
| /// Types supporting maybe-atomic bitwise operations. |
| /// |
| /// Types implementing this trait support the [`fetch_and`], [`fetch_nand`], |
| /// [`fetch_or`], and [`fetch_xor`] maybe-atomic operations. |
| /// |
| /// [`fetch_and`]: crate::Radium::fetch_and |
| /// [`fetch_nand`]: crate::Radium::fetch_nand |
| /// [`fetch_or`]: crate::Radium::fetch_or |
| /// [`fetch_xor`]: crate::Radium::fetch_xor |
| /// |
| /// `bool` and all integer fundamental types implement this. |
| /// |
| /// ```rust |
| /// # use core::sync::atomic::*; |
| /// # use radium::Radium; |
| /// let num: AtomicUsize = AtomicUsize::new(0); |
| /// Radium::fetch_or(&num, 2, Ordering::Relaxed); |
| /// ``` |
| /// |
| /// Pointers do not. This will cause a compiler error. |
| /// |
| /// ```rust,compile_fail |
| /// # use core::sync::atomic::*; |
| /// # use radium::Radium; |
| /// # use core::ptr; |
| /// let ptr: AtomicPtr<usize> = Default::default(); |
| /// Radium::fetch_or(&ptr, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| pub trait BitOps {} |
| |
| /// Types supporting maybe-atomic arithmetic operations. |
| /// |
| /// Types implementing this trait support the [`fetch_add`] and |
| /// [`fetch_sub`] maybe-atomic operations. |
| /// |
| /// [`fetch_add`]: crate::Radium::fetch_add |
| /// [`fetch_sub`]: crate::Radium::fetch_sub |
| /// |
| /// The integer types, such as `usize` and `i32`, implement this trait. |
| /// |
| /// ```rust |
| /// # use core::sync::atomic::*; |
| /// # use radium::Radium; |
| /// let num: AtomicUsize = AtomicUsize::new(2); |
| /// Radium::fetch_add(&num, 2, Ordering::Relaxed); |
| /// ``` |
| /// |
| /// `bool` and pointers do not. This will cause a compiler error. |
| /// |
| /// ```rust,compile_fail |
| /// # use core::sync::atomic::*; |
| /// # use radium::Radium; |
| /// let bit: AtomicBool = AtomicBool::new(false); |
| /// Radium::fetch_add(&bit, true, Ordering::Relaxed); |
| /// ``` |
| pub trait NumericOps: BitOps {} |
| } |
| |
| macro_rules! radium { |
| // Emit the universal `Radium` trait function bodies for atomic types. |
| ( atom $base:ty ) => { |
| #[inline] |
| fn new(value: $base) -> Self { |
| Self::new(value) |
| } |
| |
| #[inline] |
| fn fence(order: Ordering) { |
| core::sync::atomic::fence(order); |
| } |
| |
| #[inline] |
| fn get_mut(&mut self) -> &mut $base { |
| self.get_mut() |
| } |
| |
| #[inline] |
| fn into_inner(self) -> $base { |
| self.into_inner() |
| } |
| |
| #[inline] |
| fn load(&self, order: Ordering) -> $base { |
| self.load(order) |
| } |
| |
| #[inline] |
| fn store(&self, value: $base, order: Ordering) { |
| self.store(value, order); |
| } |
| |
| #[inline] |
| fn swap(&self, value: $base, order: Ordering) -> $base { |
| self.swap(value, order) |
| } |
| |
| #[inline] |
| #[allow(deprecated)] |
| fn compare_and_swap(&self, current: $base, new: $base, order: Ordering) -> $base { |
| self.compare_and_swap(current, new, order) |
| } |
| |
| #[inline] |
| fn compare_exchange( |
| &self, |
| current: $base, |
| new: $base, |
| success: Ordering, |
| failure: Ordering, |
| ) -> Result<$base, $base> { |
| self.compare_exchange(current, new, success, failure) |
| } |
| |
| #[inline] |
| fn compare_exchange_weak( |
| &self, |
| current: $base, |
| new: $base, |
| success: Ordering, |
| failure: Ordering, |
| ) -> Result<$base, $base> { |
| self.compare_exchange_weak(current, new, success, failure) |
| } |
| |
| #[inline] |
| fn fetch_update<F>( |
| &self, |
| set_order: Ordering, |
| fetch_order: Ordering, |
| f: F, |
| ) -> Result<$base, $base> |
| where |
| F: FnMut($base) -> Option<$base>, |
| { |
| self.fetch_update(set_order, fetch_order, f) |
| } |
| }; |
| |
| // Emit the `Radium` trait function bodies for bit-wise types. |
| ( atom_bit $base:ty ) => { |
| #[inline] |
| fn fetch_and(&self, value: $base, order: Ordering) -> $base { |
| self.fetch_and(value, order) |
| } |
| |
| #[inline] |
| fn fetch_nand(&self, value: $base, order: Ordering) -> $base { |
| self.fetch_nand(value, order) |
| } |
| |
| #[inline] |
| fn fetch_or(&self, value: $base, order: Ordering) -> $base { |
| self.fetch_or(value, order) |
| } |
| |
| #[inline] |
| fn fetch_xor(&self, value: $base, order: Ordering) -> $base { |
| self.fetch_xor(value, order) |
| } |
| }; |
| |
| // Emit the `Radium` trait function bodies for integral types. |
| ( atom_int $base:ty ) => { |
| #[inline] |
| fn fetch_add(&self, value: $base, order: Ordering) -> $base { |
| self.fetch_add(value, order) |
| } |
| |
| #[inline] |
| fn fetch_sub(&self, value: $base, order: Ordering) -> $base { |
| self.fetch_sub(value, order) |
| } |
| }; |
| |
| // Emit the universal `Radium` trait function bodies for `Cell<_>`. |
| ( cell $base:ty ) => { |
| #[inline] |
| fn new(value: $base) -> Self { |
| Cell::new(value) |
| } |
| |
| #[inline] |
| fn fence(_: Ordering) {} |
| |
| #[inline] |
| fn get_mut(&mut self) -> &mut $base { |
| self.get_mut() |
| } |
| |
| #[inline] |
| fn into_inner(self) -> $base { |
| self.into_inner() |
| } |
| |
| #[inline] |
| fn load(&self, _: Ordering) -> $base { |
| self.get() |
| } |
| |
| #[inline] |
| fn store(&self, value: $base, _: Ordering) { |
| self.set(value); |
| } |
| |
| #[inline] |
| fn swap(&self, value: $base, _: Ordering) -> $base { |
| self.replace(value) |
| } |
| |
| #[inline] |
| fn compare_and_swap(&self, current: $base, new: $base, _: Ordering) -> $base { |
| if self.get() == current { |
| self.replace(new) |
| } else { |
| self.get() |
| } |
| } |
| |
| #[inline] |
| fn compare_exchange( |
| &self, |
| current: $base, |
| new: $base, |
| _: Ordering, |
| _: Ordering, |
| ) -> Result<$base, $base> { |
| if self.get() == current { |
| Ok(self.replace(new)) |
| } else { |
| Err(self.get()) |
| } |
| } |
| |
| #[inline] |
| fn compare_exchange_weak( |
| &self, |
| current: $base, |
| new: $base, |
| success: Ordering, |
| failure: Ordering, |
| ) -> Result<$base, $base> { |
| Radium::compare_exchange(self, current, new, success, failure) |
| } |
| |
| #[inline] |
| fn fetch_update<F>(&self, _: Ordering, _: Ordering, mut f: F) -> Result<$base, $base> |
| where |
| F: FnMut($base) -> Option<$base>, |
| { |
| match f(self.get()) { |
| Some(x) => Ok(self.replace(x)), |
| None => Err(self.get()), |
| } |
| } |
| }; |
| |
| // Emit the `Radium` trait function bodies for bit-wise types. |
| ( cell_bit $base:ty ) => { |
| #[inline] |
| fn fetch_and(&self, value: $base, _: Ordering) -> $base { |
| self.replace(self.get() & value) |
| } |
| |
| #[inline] |
| fn fetch_nand(&self, value: $base, _: Ordering) -> $base { |
| self.replace(!(self.get() & value)) |
| } |
| |
| #[inline] |
| fn fetch_or(&self, value: $base, _: Ordering) -> $base { |
| self.replace(self.get() | value) |
| } |
| |
| #[inline] |
| fn fetch_xor(&self, value: $base, _: Ordering) -> $base { |
| self.replace(self.get() ^ value) |
| } |
| }; |
| |
| // Emit the `Radium` trait function bodies for integral types. |
| ( cell_int $base:ty ) => { |
| #[inline] |
| fn fetch_add(&self, value: $base, _: Ordering) -> $base { |
| self.replace(self.get().wrapping_add(value)) |
| } |
| |
| #[inline] |
| fn fetch_sub(&self, value: $base, _: Ordering) -> $base { |
| self.replace(self.get().wrapping_sub(value)) |
| } |
| }; |
| } |
| |
| macro_rules! radium_int { |
| ( $( $width:tt: $base:ty , $atom:ty ; )* ) => { $( |
| impl marker::BitOps for $base {} |
| impl marker::NumericOps for $base {} |
| |
| if_atomic!(if atomic($width) { |
| impl Radium for $atom { |
| type Item = $base; |
| |
| radium!(atom $base); |
| radium!(atom_bit $base); |
| radium!(atom_int $base); |
| } |
| }); |
| |
| impl Radium for Cell<$base> { |
| type Item = $base; |
| |
| radium!(cell $base); |
| radium!(cell_bit $base); |
| radium!(cell_int $base); |
| } |
| )* }; |
| } |
| |
| radium_int! { |
| 8: i8, AtomicI8; |
| 8: u8, AtomicU8; |
| 16: i16, AtomicI16; |
| 16: u16, AtomicU16; |
| 32: i32, AtomicI32; |
| 32: u32, AtomicU32; |
| 64: i64, AtomicI64; |
| 64: u64, AtomicU64; |
| size: isize, AtomicIsize; |
| size: usize, AtomicUsize; |
| } |
| |
| impl marker::BitOps for bool {} |
| |
| if_atomic!(if atomic(bool) { |
| impl Radium for AtomicBool { |
| type Item = bool; |
| |
| radium!(atom bool); |
| radium!(atom_bit bool); |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let atom = AtomicBool::new(false); |
| /// Radium::fetch_add(&atom, true, Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_add(&self, _value: bool, _order: Ordering) -> bool { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let atom = AtomicBool::new(false); |
| /// Radium::fetch_sub(&atom, true, Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_sub(&self, _value: bool, _order: Ordering) -> bool { |
| unreachable!("This method statically cannot be called") |
| } |
| } |
| }); |
| |
| impl Radium for Cell<bool> { |
| type Item = bool; |
| |
| radium!(cell bool); |
| radium!(cell_bit bool); |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let cell = Cell::<bool>::new(false); |
| /// Radium::fetch_add(&cell, true, Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_add(&self, _value: bool, _order: Ordering) -> bool { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let cell = Cell::<bool>::new(false); |
| /// Radium::fetch_sub(&cell, true, Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_sub(&self, _value: bool, _order: Ordering) -> bool { |
| unreachable!("This method statically cannot be called") |
| } |
| } |
| |
| if_atomic!(if atomic(ptr) { |
| impl<T> Radium for AtomicPtr<T> { |
| type Item = *mut T; |
| |
| radium!(atom *mut T); |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let atom = AtomicPtr::<u8>::new(ptr::null_mut()); |
| /// Radium::fetch_and(&atom, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_and(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let atom = AtomicPtr::<u8>::new(ptr::null_mut()); |
| /// Radium::fetch_nand(&atom, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_nand(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let atom = AtomicPtr::<u8>::new(ptr::null_mut()); |
| /// Radium::fetch_or(&atom, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_or(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let atom = AtomicPtr::<u8>::new(ptr::null_mut()); |
| /// Radium::fetch_xor(&atom, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_xor(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let atom = AtomicPtr::<u8>::new(ptr::null_mut()); |
| /// Radium::fetch_add(&atom, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_add(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let atom = AtomicPtr::<u8>::new(ptr::null_mut()); |
| /// Radium::fetch_sub(&atom, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_sub(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| } |
| }); |
| |
| impl<T> Radium for Cell<*mut T> { |
| type Item = *mut T; |
| |
| radium!(cell *mut T); |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let cell = Cell::<*mut u8>::new(ptr::null_mut()); |
| /// Radium::fetch_and(&cell, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_and(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let cell = Cell::<*mut u8>::new(ptr::null_mut()); |
| /// Radium::fetch_nand(&cell, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_nand(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let cell = Cell::<*mut u8>::new(ptr::null_mut()); |
| /// Radium::fetch_or(&cell, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_or(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let cell = Cell::<*mut u8>::new(ptr::null_mut()); |
| /// Radium::fetch_xor(&cell, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_xor(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let cell = Cell::<*mut u8>::new(ptr::null_mut()); |
| /// Radium::fetch_add(&cell, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_add(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| |
| /// ```compile_fail |
| /// # use std::{ptr, sync::atomic::*, cell::*}; |
| /// # use radium::*; |
| /// let cell = Cell::<*mut u8>::new(ptr::null_mut()); |
| /// Radium::fetch_sub(&cell, ptr::null_mut(), Ordering::Relaxed); |
| /// ``` |
| #[doc(hidden)] |
| fn fetch_sub(&self, _value: *mut T, _order: Ordering) -> *mut T { |
| unreachable!("This method statically cannot be called") |
| } |
| } |
| |
| #[cfg(test)] |
| mod tests { |
| use super::*; |
| use core::cell::Cell; |
| |
| #[test] |
| fn absent_traits() { |
| static_assertions::assert_not_impl_any!(bool: marker::NumericOps); |
| static_assertions::assert_not_impl_any!(*mut u8: marker::BitOps, marker::NumericOps); |
| } |
| |
| #[test] |
| fn present_traits() { |
| static_assertions::assert_impl_all!(bool: marker::BitOps); |
| static_assertions::assert_impl_all!(usize: marker::BitOps, marker::NumericOps); |
| } |
| |
| #[test] |
| fn always_cell() { |
| static_assertions::assert_impl_all!(Cell<bool>: Radium<Item = bool>); |
| static_assertions::assert_impl_all!(Cell<i8>: Radium<Item = i8>); |
| static_assertions::assert_impl_all!(Cell<u8>: Radium<Item = u8>); |
| static_assertions::assert_impl_all!(Cell<i16>: Radium<Item = i16>); |
| static_assertions::assert_impl_all!(Cell<u16>: Radium<Item = u16>); |
| static_assertions::assert_impl_all!(Cell<i32>: Radium<Item = i32>); |
| static_assertions::assert_impl_all!(Cell<u32>: Radium<Item = u32>); |
| static_assertions::assert_impl_all!(Cell<i64>: Radium<Item = i64>); |
| static_assertions::assert_impl_all!(Cell<u64>: Radium<Item = u64>); |
| static_assertions::assert_impl_all!(Cell<isize>: Radium<Item = isize>); |
| static_assertions::assert_impl_all!(Cell<usize>: Radium<Item = usize>); |
| static_assertions::assert_impl_all!(Cell<*mut ()>: Radium<Item = *mut ()>); |
| } |
| |
| #[test] |
| fn always_alias() { |
| static_assertions::assert_impl_all!(types::RadiumBool: Radium<Item = bool>); |
| static_assertions::assert_impl_all!(types::RadiumI8: Radium<Item = i8>); |
| static_assertions::assert_impl_all!(types::RadiumU8: Radium<Item = u8>); |
| static_assertions::assert_impl_all!(types::RadiumI16: Radium<Item = i16>); |
| static_assertions::assert_impl_all!(types::RadiumU16: Radium<Item = u16>); |
| static_assertions::assert_impl_all!(types::RadiumI32: Radium<Item = i32>); |
| static_assertions::assert_impl_all!(types::RadiumU32: Radium<Item = u32>); |
| static_assertions::assert_impl_all!(types::RadiumI64: Radium<Item = i64>); |
| static_assertions::assert_impl_all!(types::RadiumU64: Radium<Item = u64>); |
| static_assertions::assert_impl_all!(types::RadiumIsize: Radium<Item = isize>); |
| static_assertions::assert_impl_all!(types::RadiumUsize: Radium<Item = usize>); |
| static_assertions::assert_impl_all!(types::RadiumPtr<()>: Radium<Item = *mut ()>); |
| } |
| |
| #[test] |
| fn maybe_atom() { |
| if_atomic! { |
| if atomic(bool) { |
| use core::sync::atomic::*; |
| static_assertions::assert_impl_all!(AtomicBool: Radium<Item = bool>); |
| } |
| if atomic(8) { |
| static_assertions::assert_impl_all!(AtomicI8: Radium<Item = i8>); |
| static_assertions::assert_impl_all!(AtomicU8: Radium<Item = u8>); |
| } |
| if atomic(16) { |
| static_assertions::assert_impl_all!(AtomicI16: Radium<Item = i16>); |
| static_assertions::assert_impl_all!(AtomicU16: Radium<Item = u16>); |
| } |
| if atomic(32) { |
| static_assertions::assert_impl_all!(AtomicI32: Radium<Item = i32>); |
| static_assertions::assert_impl_all!(AtomicU32: Radium<Item = u32>); |
| } |
| if atomic(64) { |
| static_assertions::assert_impl_all!(AtomicI64: Radium<Item = i64>); |
| static_assertions::assert_impl_all!(AtomicU64: Radium<Item = u64>); |
| } |
| if atomic(size) { |
| static_assertions::assert_impl_all!(AtomicIsize: Radium<Item = isize>); |
| static_assertions::assert_impl_all!(AtomicUsize: Radium<Item = usize>); |
| } |
| if atomic(ptr) { |
| static_assertions::assert_impl_all!(AtomicPtr<()>: Radium<Item = *mut ()>); |
| } |
| } |
| } |
| } |
