Struct bones_framework::prelude::RefMut
pub struct RefMut<'a, T>where
T: ?Sized,{ /* private fields */ }
Expand description
Wrapper for mutably borrowed AtomicCell
that will released lock on drop.
This type can be dereferenced to [&mut T
].
Implements Borrow<T>
, BorrowMut<T>
, AsRef<T>
and AsMut<T>
for convenience.
Implements Debug
, Display
, PartialEq
, PartialOrd
and Hash
by delegating to T
.
Implementations§
§impl<'a, T> RefMut<'a, T>where
T: ?Sized,
impl<'a, T> RefMut<'a, T>where
T: ?Sized,
pub fn new(r: &'a mut T) -> RefMut<'a, T>
pub fn new(r: &'a mut T) -> RefMut<'a, T>
Wraps external reference into RefMut
.
This function’s purpose is to satisfy type requirements
where RefMut
is required but reference does not live in AtomicCell
.
§Examples
use atomicell::RefMut;
let mut value = 42;
let r = RefMut::new(&mut value);
pub fn with_borrow(r: &'a mut T, borrow: AtomicBorrowMut<'a>) -> RefMut<'a, T>
pub fn with_borrow(r: &'a mut T, borrow: AtomicBorrowMut<'a>) -> RefMut<'a, T>
Wraps external reference into RefMut
.
And associates it with provided AtomicBorrowMut
This function is intended to be used by AtomicCell
or other abstractions that use AtomicBorrow
for locking.
§Examples
use core::sync::atomic::AtomicIsize;
use atomicell::{borrow::{AtomicBorrowMut, new_lock}, RefMut};
let counter = new_lock();
let borrow = AtomicBorrowMut::try_new(&counter).unwrap();
let mut value = 42;
let r = RefMut::with_borrow(&mut value, borrow);
assert_eq!(*r, 42);
pub fn into_split(r: RefMut<'a, T>) -> (NonNull<T>, AtomicBorrowMut<'a>)
pub fn into_split(r: RefMut<'a, T>) -> (NonNull<T>, AtomicBorrowMut<'a>)
Splits wrapper into two parts. One is reference to the value and the other is
AtomicBorrowMut
that guards it from being borrowed.
§Safety
User must ensure NonNull
is not dereferenced after AtomicBorrowMut
is dropped.
You must also treat the NonNull
as invariant over T
. This means that any custom
wrapper types you make around the NonNull<T>
must also be invariant over T
. This can
be done by adding a PhantomData<*mut T>
field to the struct.
See the source definition of RefMut
for an example.
§Examples
use atomicell::{AtomicCell, RefMut};
let cell = AtomicCell::new(42);
let r: RefMut<'_, i32> = cell.borrow_mut();
unsafe {
let (r, borrow) = RefMut::into_split(r);
assert_eq!(*r.as_ref(), 42);
assert!(cell.try_borrow().is_none(), "Must not be able to borrow mutably yet");
assert!(cell.try_borrow_mut().is_none(), "Must not be able to borrow mutably yet");
drop(borrow);
assert!(cell.try_borrow_mut().is_some(), "Must be able to borrow mutably now");
}
pub fn map<F, U>(r: RefMut<'a, T>, f: F) -> RefMut<'a, U>
pub fn map<F, U>(r: RefMut<'a, T>, f: F) -> RefMut<'a, U>
Makes a new RefMut
for a component of the borrowed data.
The AtomicCell
is already mutably borrowed, so this cannot fail.
This is an associated function that needs to be used as RefMut::map(…).
A method would interfere with methods of the same name on the contents of a AtomicCell
used through Deref
.
§Examples
use atomicell::{AtomicCell, RefMut};
let c = AtomicCell::new((5, 'b'));
let b1: RefMut<(u32, char)> = c.borrow_mut();
let b2: RefMut<u32> = RefMut::map(b1, |t| &mut t.0);
assert_eq!(*b2, 5)
pub fn filter_map<U, F>(
r: RefMut<'a, T>,
f: F,
) -> Result<RefMut<'a, U>, RefMut<'a, T>>
pub fn filter_map<U, F>( r: RefMut<'a, T>, f: F, ) -> Result<RefMut<'a, U>, RefMut<'a, T>>
Makes a new RefMut
for an optional component of the borrowed data.
The original guard is returned as an Err(..) if the closure returns None.
The AtomicCell
is already mutably borrowed, so this cannot fail.
This is an associated function that needs to be used as RefMut::filter_map(…).
A method would interfere with methods of the same name on the contents of a AtomicCell
used through Deref
.
§Examples
use atomicell::{AtomicCell, RefMut};
let c = AtomicCell::new(vec![1, 2, 3]);
{
let b1: RefMut<Vec<u32>> = c.borrow_mut();
let mut b2: Result<RefMut<u32>, _> = RefMut::filter_map(b1, |v| v.get_mut(1));
if let Ok(mut b2) = b2 {
*b2 += 2;
}
}
assert_eq!(*c.borrow(), vec![1, 4, 3]);
pub fn map_split<U, V, F>(
r: RefMut<'a, T>,
f: F,
) -> (RefMut<'a, U>, RefMut<'a, V>)
pub fn map_split<U, V, F>( r: RefMut<'a, T>, f: F, ) -> (RefMut<'a, U>, RefMut<'a, V>)
Splits a RefMut
into multiple RefMut
s for different components of the borrowed data.
The AtomicCell
is already immutably borrowed, so this cannot fail.
This is an associated function that needs to be used as RefMut::map_split(...)
.
A method would interfere with methods of the same name on the contents of a AtomicCell
used through Deref
.
§Examples
use atomicell::{RefMut, AtomicCell};
let cell = AtomicCell::new([1, 2, 3, 4]);
let borrow = cell.borrow_mut();
let (begin, end) = RefMut::map_split(borrow, |slice| slice.split_at_mut(2));
assert_eq!(*begin, [1, 2]);
assert_eq!(*end, [3, 4]);
pub fn leak(r: RefMut<'a, T>) -> &'a mut T
pub fn leak(r: RefMut<'a, T>) -> &'a mut T
Convert into a reference to the underlying data.
The underlying AtomicCell
can never be mutably borrowed from again
and will always appear already immutably borrowed.
It is not a good idea to leak more than a constant number of references.
The AtomicCell
can be immutably borrowed again if only a smaller number of leaks have occurred in total.
This is an associated function that needs to be used as RefMut::leak(…).
A method would interfere with methods of the same name on the contents of a AtomicCell
used through Deref
.
§Examples
use atomicell::{AtomicCell, RefMut};
let cell = AtomicCell::new(0);
let value = RefMut::leak(cell.borrow_mut());
assert_eq!(*value, 0);
*value = 1;
assert_eq!(*value, 1);
assert!(cell.try_borrow().is_none());
assert!(cell.try_borrow_mut().is_none());
pub fn as_mut<U>(r: RefMut<'a, T>) -> RefMut<'a, U>
pub fn as_mut<U>(r: RefMut<'a, T>) -> RefMut<'a, U>
Converts reference and returns result wrapped in the RefMut
.
The AtomicCell
is already mutably borrowed, so this cannot fail.
This is an associated function that needs to be used as RefMut::map_split(...)
.
A method would interfere with methods of the same name on the contents of a AtomicCell
used through Deref
.
§Examples
use atomicell::{AtomicCell, RefMut};
let c = AtomicCell::new(String::from("hello"));
let b1: RefMut<String> = c.borrow_mut();
let mut b2: RefMut<str> = RefMut::as_mut(b1);
b2.make_ascii_uppercase();
assert_eq!(*b2, *"HELLO")
pub fn as_deref_mut(r: RefMut<'a, T>) -> RefMut<'a, <T as Deref>::Target>where
T: DerefMut,
pub fn as_deref_mut(r: RefMut<'a, T>) -> RefMut<'a, <T as Deref>::Target>where
T: DerefMut,
Dereferences and returns result wrapped in the RefMut
.
The AtomicCell
is already mutably borrowed, so this cannot fail.
This is an associated function that needs to be used as RefMut::map_split(...)
.
A method would interfere with methods of the same name on the contents of a AtomicCell
used through Deref
.
§Examples
use atomicell::{AtomicCell, RefMut};
let c = AtomicCell::new(String::from("hello"));
let b1: RefMut<String> = c.borrow_mut();
let mut b2: RefMut<str> = RefMut::as_deref_mut(b1);
b2.make_ascii_uppercase();
assert_eq!(*b2, *"HELLO")
§impl<'a, T> RefMut<'a, Option<T>>
impl<'a, T> RefMut<'a, Option<T>>
pub fn transpose(r: RefMut<'a, Option<T>>) -> Option<RefMut<'a, T>>
pub fn transpose(r: RefMut<'a, Option<T>>) -> Option<RefMut<'a, T>>
Transposes a RefMut
of an Option
into an Option
of a RefMut
.
Releases shared lock of AtomicCell
if the value is None
.
The AtomicCell
is already mutably borrowed, so this cannot fail.
This is an associated function that needs to be used as RefMut::map_split(...)
.
A method would interfere with methods of the same name on the contents of a AtomicCell
used through Deref
.
§Examples
use atomicell::{AtomicCell, RefMut};
let c = AtomicCell::new(Some(5));
let b1: RefMut<Option<i32>> = c.borrow_mut();
let b2: Option<RefMut<i32>> = RefMut::transpose(b1);
assert!(b2.is_some());
let c = AtomicCell::new(None);
let b1: RefMut<Option<i32>> = c.borrow_mut();
let b2: Option<RefMut<i32>> = RefMut::transpose(b1);
assert!(b2.is_none());
assert!(c.try_borrow_mut().is_some());
§impl<'a, T> RefMut<'a, [T]>
impl<'a, T> RefMut<'a, [T]>
pub fn slice<R>(r: RefMut<'a, [T]>, range: R) -> RefMut<'a, [T]>where
R: RangeBounds<usize>,
pub fn slice<R>(r: RefMut<'a, [T]>, range: R) -> RefMut<'a, [T]>where
R: RangeBounds<usize>,
Makes a new RefMut
for a sub-slice of the borrowed slice.
The AtomicCell
is already mutably borrowed, so this cannot fail.
This is an associated function that needs to be used as RefMut::map(…).
A method would interfere with methods of the same name on the contents of a AtomicCell
used through Deref
.
§Examples
use atomicell::{AtomicCell, RefMut};
let c: &AtomicCell<[i32]> = &AtomicCell::new([1, 2, 3, 4, 5]);
let b1: RefMut<[i32]> = RefMut::as_mut(c.borrow_mut());
let b2: RefMut<[i32]> = RefMut::slice(b1, 2..4);
assert_eq!(*b2, [3, 4])
Trait Implementations§
§impl<'a, T> BorrowMut<T> for RefMut<'a, T>where
T: ?Sized,
impl<'a, T> BorrowMut<T> for RefMut<'a, T>where
T: ?Sized,
§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<'a, T, U> PartialOrd<U> for RefMut<'a, T>where
T: PartialOrd<U> + ?Sized,
impl<'a, T, U> PartialOrd<U> for RefMut<'a, T>where
T: PartialOrd<U> + ?Sized,
source§impl<'a, 'q, T> QueryItem for &'a RefMut<'q, ComponentStore<T>>where
T: HasSchema,
impl<'a, 'q, T> QueryItem for &'a RefMut<'q, ComponentStore<T>>where
T: HasSchema,
§type Iter = Map<UntypedComponentBitsetIterator<'a>, for<'b> fn(_: SchemaRef<'b>) -> &'b T>
type Iter = Map<UntypedComponentBitsetIterator<'a>, for<'b> fn(_: SchemaRef<'b>) -> &'b T>
source§fn apply_bitset(&self, bitset: &mut BitSetVec)
fn apply_bitset(&self, bitset: &mut BitSetVec)
source§fn get_single_with_bitset(
self,
bitset: Rc<BitSetVec>,
) -> Result<<<&'a RefMut<'q, ComponentStore<T>> as QueryItem>::Iter as Iterator>::Item, QuerySingleError>
fn get_single_with_bitset( self, bitset: Rc<BitSetVec>, ) -> Result<<<&'a RefMut<'q, ComponentStore<T>> as QueryItem>::Iter as Iterator>::Item, QuerySingleError>
source§fn iter_with_bitset(
self,
bitset: Rc<BitSetVec>,
) -> <&'a RefMut<'q, ComponentStore<T>> as QueryItem>::Iter
fn iter_with_bitset( self, bitset: Rc<BitSetVec>, ) -> <&'a RefMut<'q, ComponentStore<T>> as QueryItem>::Iter
source§impl<'a, 'q, T> QueryItem for &'a mut RefMut<'q, ComponentStore<T>>where
T: HasSchema,
impl<'a, 'q, T> QueryItem for &'a mut RefMut<'q, ComponentStore<T>>where
T: HasSchema,
§type Iter = Map<UntypedComponentBitsetIteratorMut<'a>, for<'b> fn(_: SchemaRefMut<'b>) -> &'b mut T>
type Iter = Map<UntypedComponentBitsetIteratorMut<'a>, for<'b> fn(_: SchemaRefMut<'b>) -> &'b mut T>
source§fn apply_bitset(&self, bitset: &mut BitSetVec)
fn apply_bitset(&self, bitset: &mut BitSetVec)
source§fn get_single_with_bitset(
self,
bitset: Rc<BitSetVec>,
) -> Result<<<&'a mut RefMut<'q, ComponentStore<T>> as QueryItem>::Iter as Iterator>::Item, QuerySingleError>
fn get_single_with_bitset( self, bitset: Rc<BitSetVec>, ) -> Result<<<&'a mut RefMut<'q, ComponentStore<T>> as QueryItem>::Iter as Iterator>::Item, QuerySingleError>
source§fn iter_with_bitset(
self,
bitset: Rc<BitSetVec>,
) -> <&'a mut RefMut<'q, ComponentStore<T>> as QueryItem>::Iter
fn iter_with_bitset( self, bitset: Rc<BitSetVec>, ) -> <&'a mut RefMut<'q, ComponentStore<T>> as QueryItem>::Iter
source§impl<'a, T> SystemParam for RefMut<'a, ComponentStore<T>>where
T: HasSchema,
impl<'a, T> SystemParam for RefMut<'a, ComponentStore<T>>where
T: HasSchema,
§type State = Arc<AtomicCell<ComponentStore<T>>>
type State = Arc<AtomicCell<ComponentStore<T>>>
§type Param<'p> = RefMut<'p, ComponentStore<T>>
type Param<'p> = RefMut<'p, ComponentStore<T>>
source§fn get_state(
world: &World,
) -> <RefMut<'a, ComponentStore<T>> as SystemParam>::State
fn get_state( world: &World, ) -> <RefMut<'a, ComponentStore<T>> as SystemParam>::State
source§fn borrow<'s>(
_world: &'s World,
state: &'s mut <RefMut<'a, ComponentStore<T>> as SystemParam>::State,
) -> <RefMut<'a, ComponentStore<T>> as SystemParam>::Param<'s>
fn borrow<'s>( _world: &'s World, state: &'s mut <RefMut<'a, ComponentStore<T>> as SystemParam>::State, ) -> <RefMut<'a, ComponentStore<T>> as SystemParam>::Param<'s>
impl<'b, T> Send for RefMut<'b, T>
impl<'b, T> Sync for RefMut<'b, T>
Auto Trait Implementations§
impl<'a, T> Freeze for RefMut<'a, T>where
T: ?Sized,
impl<'a, T> RefUnwindSafe for RefMut<'a, T>where
T: RefUnwindSafe + ?Sized,
impl<'a, T> Unpin for RefMut<'a, T>where
T: ?Sized,
impl<'a, T> !UnwindSafe for RefMut<'a, T>
Blanket Implementations§
§impl<T> AnyEq for T
impl<T> AnyEq for T
§impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedExplicit<'a, E> for Twhere
T: 'a,
§impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
impl<'a, T, E> AsTaggedImplicit<'a, E> for Twhere
T: 'a,
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
§impl<T> Conv for T
impl<T> Conv for T
§impl<T> FmtForward for T
impl<T> FmtForward for T
§fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
fn fmt_binary(self) -> FmtBinary<Self>where
Self: Binary,
self
to use its Binary
implementation when Debug
-formatted.§fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
fn fmt_display(self) -> FmtDisplay<Self>where
Self: Display,
self
to use its Display
implementation when
Debug
-formatted.§fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
fn fmt_lower_exp(self) -> FmtLowerExp<Self>where
Self: LowerExp,
self
to use its LowerExp
implementation when
Debug
-formatted.§fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
fn fmt_lower_hex(self) -> FmtLowerHex<Self>where
Self: LowerHex,
self
to use its LowerHex
implementation when
Debug
-formatted.§fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
fn fmt_octal(self) -> FmtOctal<Self>where
Self: Octal,
self
to use its Octal
implementation when Debug
-formatted.§fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
fn fmt_pointer(self) -> FmtPointer<Self>where
Self: Pointer,
self
to use its Pointer
implementation when
Debug
-formatted.§fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
fn fmt_upper_exp(self) -> FmtUpperExp<Self>where
Self: UpperExp,
self
to use its UpperExp
implementation when
Debug
-formatted.§fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
fn fmt_upper_hex(self) -> FmtUpperHex<Self>where
Self: UpperHex,
self
to use its UpperHex
implementation when
Debug
-formatted.§fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
fn fmt_list(self) -> FmtList<Self>where
&'a Self: for<'a> IntoIterator,
§impl<S> FromSample<S> for S
impl<S> FromSample<S> for S
fn from_sample_(s: S) -> S
§impl<T> Instrument for T
impl<T> Instrument for T
§fn instrument(self, span: Span) -> Instrumented<Self>
fn instrument(self, span: Span) -> Instrumented<Self>
§fn in_current_span(self) -> Instrumented<Self>
fn in_current_span(self) -> Instrumented<Self>
§impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
impl<F, T> IntoSample<T> for Fwhere
T: FromSample<F>,
fn into_sample(self) -> T
§impl<T> Pipe for Twhere
T: ?Sized,
impl<T> Pipe for Twhere
T: ?Sized,
§fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
fn pipe<R>(self, func: impl FnOnce(Self) -> R) -> Rwhere
Self: Sized,
§fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref<'a, R>(&'a self, func: impl FnOnce(&'a Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
fn pipe_ref_mut<'a, R>(&'a mut self, func: impl FnOnce(&'a mut Self) -> R) -> Rwhere
R: 'a,
self
and passes that borrow into the pipe function. Read more§fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
fn pipe_borrow<'a, B, R>(&'a self, func: impl FnOnce(&'a B) -> R) -> R
§fn pipe_borrow_mut<'a, B, R>(
&'a mut self,
func: impl FnOnce(&'a mut B) -> R,
) -> R
fn pipe_borrow_mut<'a, B, R>( &'a mut self, func: impl FnOnce(&'a mut B) -> R, ) -> R
§fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
fn pipe_as_ref<'a, U, R>(&'a self, func: impl FnOnce(&'a U) -> R) -> R
self
, then passes self.as_ref()
into the pipe function.§fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
fn pipe_as_mut<'a, U, R>(&'a mut self, func: impl FnOnce(&'a mut U) -> R) -> R
self
, then passes self.as_mut()
into the pipe
function.§fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
fn pipe_deref<'a, T, R>(&'a self, func: impl FnOnce(&'a T) -> R) -> R
self
, then passes self.deref()
into the pipe function.§impl<T> Tap for T
impl<T> Tap for T
§fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow<B>(self, func: impl FnOnce(&B)) -> Self
Borrow<B>
of a value. Read more§fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut<B>(self, func: impl FnOnce(&mut B)) -> Self
BorrowMut<B>
of a value. Read more§fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref<R>(self, func: impl FnOnce(&R)) -> Self
AsRef<R>
view of a value. Read more§fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut<R>(self, func: impl FnOnce(&mut R)) -> Self
AsMut<R>
view of a value. Read more§fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref<T>(self, func: impl FnOnce(&T)) -> Self
Deref::Target
of a value. Read more§fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
fn tap_deref_mut<T>(self, func: impl FnOnce(&mut T)) -> Self
Deref::Target
of a value. Read more§fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
fn tap_dbg(self, func: impl FnOnce(&Self)) -> Self
.tap()
only in debug builds, and is erased in release builds.§fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
fn tap_mut_dbg(self, func: impl FnOnce(&mut Self)) -> Self
.tap_mut()
only in debug builds, and is erased in release
builds.§fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
fn tap_borrow_dbg<B>(self, func: impl FnOnce(&B)) -> Self
.tap_borrow()
only in debug builds, and is erased in release
builds.§fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
fn tap_borrow_mut_dbg<B>(self, func: impl FnOnce(&mut B)) -> Self
.tap_borrow_mut()
only in debug builds, and is erased in release
builds.§fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
fn tap_ref_dbg<R>(self, func: impl FnOnce(&R)) -> Self
.tap_ref()
only in debug builds, and is erased in release
builds.§fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
fn tap_ref_mut_dbg<R>(self, func: impl FnOnce(&mut R)) -> Self
.tap_ref_mut()
only in debug builds, and is erased in release
builds.§fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
fn tap_deref_dbg<T>(self, func: impl FnOnce(&T)) -> Self
.tap_deref()
only in debug builds, and is erased in release
builds.