Struct bones_ecs::prelude::AtomicCell

pub struct AtomicCell<T>
where
    T: ?Sized,
{ /* private fields */ }

A mutable memory location with dynamically checked borrow rules This type behaves mostly like core::cell::RefCell. The main difference is that this type uses atomic operations for borrowing. Thus allowing to use it in multi-threaded environment.

AtomicCell<T> implements Send if T: Send. AtomicCell<T> implements Sync if T: Send + Sync.

Implementations

impl<T> AtomicCell<T>

pub const fn new(value: T) -> AtomicCell<T>

Creates a new AtomicCell containing value.

Examples

use atomicell::AtomicCell;

let cell = AtomicCell::new(5);

pub fn into_inner(self) -> T

Consumes the AtomicCell, returning the wrapped value.

Examples

use atomicell::AtomicCell;

let c = AtomicCell::new(5);

let five = c.into_inner();

pub fn replace(&self, t: T) -> T

Replaces the wrapped value with a new one, returning the old value, without deinitializing either one.

This function corresponds to core::mem::replace.

Panics

Panics if the value is currently borrowed.

Examples

use atomicell::AtomicCell;
let cell = AtomicCell::new(5);
let old_value = cell.replace(6);
assert_eq!(old_value, 5);
assert_eq!(cell, AtomicCell::new(6));

pub fn replace_with<F>(&self, f: F) -> T

where F: FnOnce(&mut T) -> T,

Replaces the wrapped value with a new one computed from f, returning the old value, without deinitializing either one.

Panics

Panics if the value is currently borrowed.

Examples

use atomicell::AtomicCell;
let cell = AtomicCell::new(5);
let old_value = cell.replace_with(|&mut old| old + 1);
assert_eq!(old_value, 5);
assert_eq!(cell, AtomicCell::new(6));

pub fn swap(&self, other: &AtomicCell<T>)

Swaps the wrapped value of self with the wrapped value of other, without deinitializing either one.

This function corresponds to core::mem::swap.

Panics

Panics if the value in either AtomicCell is currently borrowed.

Examples

use atomicell::AtomicCell;
let c = AtomicCell::new(5);
let d = AtomicCell::new(6);
c.swap(&d);
assert_eq!(c, AtomicCell::new(6));
assert_eq!(d, AtomicCell::new(5));

impl<T> AtomicCell<T>

where T: ?Sized,

pub fn try_borrow(&self) -> Option<Ref<'_, T>>

Immutably borrows the wrapped value, returning None if the value is currently mutably borrowed.

The borrow lasts until the returned Ref, all Refs derived from it and all its clones exit scope.

Multiple immutable borrows can be taken out at the same time.

This is the non-panicking variant of borrow.

Examples

use atomicell::AtomicCell;
let c = AtomicCell::new(5);

{
    let m = c.borrow_mut();
    assert!(c.try_borrow().is_none());
}

{
    let m = c.borrow();
    assert!(c.try_borrow().is_some());
}

pub fn borrow(&self) -> Ref<'_, T>

Immutably borrows the wrapped value.

The borrow lasts until the returned Ref, all Refs derived from it and all its clones exit scope.

Multiple immutable borrows can be taken out at the same time.

Panics

Panics if the value is currently mutably borrowed. For a non-panicking variant, use try_borrow.

Examples

use atomicell::AtomicCell;

let c = AtomicCell::new(5);

let borrowed_five = c.borrow();
let borrowed_five2 = c.borrow();

An example of panic:

use atomicell::AtomicCell;

let c = AtomicCell::new(5);

let m = c.borrow_mut();
let b = c.borrow(); // this causes a panic

pub fn try_borrow_mut(&self) -> Option<RefMut<'_, T>>

Mutably borrows the wrapped value, returning an error if the value is currently borrowed.

The borrow lasts until the returned RefMut or all RefMuts derived from it exit scope.

The value cannot be borrowed while this borrow is active.

This is the non-panicking variant of borrow_mut.

Examples

use atomicell::AtomicCell;

let c = AtomicCell::new(5);

{
    let m = c.borrow();
    assert!(c.try_borrow_mut().is_none());
}

assert!(c.try_borrow_mut().is_some());

pub fn borrow_mut(&self) -> RefMut<'_, T>

Mutably borrows the wrapped value.

The borrow lasts until the returned RefMut or all RefMuts derived from it exit scope.

The value cannot be borrowed while this borrow is active.

Panics

Panics if the value is currently borrowed. For a non-panicking variant, use try_borrow_mut.

Examples

use atomicell::AtomicCell;

let c = AtomicCell::new("hello".to_owned());

*c.borrow_mut() = "bonjour".to_owned();

assert_eq!(&*c.borrow(), "bonjour");

An example of panic:

use atomicell::AtomicCell;

let c = AtomicCell::new(5);
let m = c.borrow();

let b = c.borrow_mut(); // this causes a panic

pub const fn as_ptr(&self) -> *mut T

Returns a raw pointer to the underlying data in this cell.

Examples

use atomicell::AtomicCell;

let c = AtomicCell::new(5);

let ptr = c.as_ptr();

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

Returns a mutable reference to the underlying data.

This call borrows AtomicCell mutably (at compile-time) so there is no need for dynamic checks.

However be cautious: this method expects self to be mutable, which is generally not the case when using a AtomicCell. Take a look at the borrow_mut method instead if self isn’t mutable.

Also, please be aware that this method is only for special circumstances and is usually not what you want. In case of doubt, use borrow_mut instead.

Examples

use atomicell::AtomicCell;

let mut c = AtomicCell::new(5);
*c.get_mut() += 1;

assert_eq!(c, AtomicCell::new(6));

pub fn undo_leak(&mut self) -> &mut T

Undo the effect of leaked guards on the borrow state of the AtomicCell.

This call is similar to get_mut but more specialized. It borrows AtomicCell mutably to ensure no borrows exist and then resets the state tracking shared borrows. This is relevant if some Ref or RefMut borrows have been leaked.

Examples

use atomicell::AtomicCell;

let mut c = AtomicCell::new(0);
core::mem::forget(c.borrow_mut());

assert!(c.try_borrow().is_none());
c.undo_leak();
assert!(c.try_borrow().is_some());

pub unsafe fn try_borrow_unguarded(&self) -> Option<&T>

Immutably borrows the wrapped value, returning None if the value is currently mutably borrowed.

Safety

Unlike borrow, this method is unsafe because it does not return a Ref, thus leaving the borrow flag untouched.

Mutably borrowing the AtomicCell while the reference returned by this method is alive is undefined behaviour.

Examples

use atomicell::AtomicCell;

let c = AtomicCell::new(5);

{
    assert!(unsafe { c.try_borrow_unguarded() }.is_some());
    let m = c.borrow_mut();
    assert!(unsafe { c.try_borrow_unguarded() }.is_none());
}

{
    let m = c.borrow();
    assert!(unsafe { c.try_borrow_unguarded() }.is_some());
}

pub unsafe fn try_borrow_unguarded_mut(&self) -> Option<&mut T>

Mutably borrows the wrapped value, returning None if the value is currently mutably borrowed.

Safety

Unlike borrow_mut, this method is unsafe because it does not return a Ref, and leaves the borrow flag untouched.

Borrowing the AtomicCell while the reference returned by this method is alive is undefined behaviour.

Examples

use atomicell::AtomicCell;

let c = AtomicCell::new(5);

{
    assert!(unsafe { c.try_borrow_unguarded_mut() }.is_some());
    let m = c.borrow();
    assert!(unsafe { c.try_borrow_unguarded_mut() }.is_none());
}

impl<T> AtomicCell<T>

where T: Default,

pub fn take(&self) -> T

Takes the wrapped value, leaving Default::default() in its place.

Panics

Panics if the value is currently borrowed.

Examples

use atomicell::AtomicCell;

let c = AtomicCell::new(5);
let five = c.take();

assert_eq!(five, 5);
assert_eq!(c.into_inner(), 0);

Trait Implementations

impl<T> Clone for AtomicCell<T>

where T: Clone,

fn clone(&self) -> AtomicCell<T>

Returns a copy of the value.

fn clone_from(&mut self, other: &AtomicCell<T>)

Performs copy-assignment from source.

impl<T> Debug for AtomicCell<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Display for AtomicCell<T>

where T: Display,

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

Formats the value using the given formatter.

impl<T> From<T> for AtomicCell<T>

fn from(t: T) -> AtomicCell<T>

Converts to this type from the input type.

impl<T> Ord for AtomicCell<T>

where T: Ord,

fn cmp(&self, other: &AtomicCell<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl<T, U> PartialEq<AtomicCell<U>> for AtomicCell<T>

where T: PartialEq<U>,

fn eq(&self, other: &AtomicCell<U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T, U> PartialOrd<AtomicCell<U>> for AtomicCell<T>

where T: PartialOrd<U>,

fn partial_cmp(&self, other: &AtomicCell<U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T> Eq for AtomicCell<T>

where T: Eq,

impl<T> Send for AtomicCell<T>

where T: Send,

AtomicCell can be sent to another thread if value can be sent. Sending can occur on owned cell or mutable reference to it. Either way it is not borrowed, so it is impossible to share stored value this way.

impl<T> Sync for AtomicCell<T>

where T: Send + Sync,

AtomicCell can be shared across threads if value can be sent and shared. Requires T: Send because mutable borrow can occur in another thread. Requires T: Sync because immutable borrows could occur concurrently in different threads.