Struct rustc_data_structures::owning_ref::OwningRefMut
source · Expand description
An mutable owning reference.
This wraps an owner O
and a reference &mut T
pointing
at something reachable from O::Target
while keeping
the ability to move self
around.
The owner is usually a pointer that points at some base type.
For more details and examples, see the module and method docs.
Fields§
§owner: O
§reference: *mut T
Implementations§
source§impl<O, T: ?Sized> OwningRefMut<O, T>
impl<O, T: ?Sized> OwningRefMut<O, T>
sourcepub fn new(o: O) -> Selfwhere
O: StableAddress + DerefMut<Target = T>,
pub fn new(o: O) -> Selfwhere
O: StableAddress + DerefMut<Target = T>,
Creates a new owning reference from an owner initialized to the direct dereference of it.
Example
use rustc_data_structures::owning_ref::OwningRefMut;
fn main() {
let owning_ref_mut = OwningRefMut::new(Box::new(42));
assert_eq!(*owning_ref_mut, 42);
}
sourcepub unsafe fn new_assert_stable_address(o: O) -> Selfwhere
O: DerefMut<Target = T>,
pub unsafe fn new_assert_stable_address(o: O) -> Selfwhere
O: DerefMut<Target = T>,
Like new
, but doesn’t require O
to implement the StableAddress
trait.
Instead, the caller is responsible to make the same promises as implementing the trait.
This is useful for cases where coherence rules prevents implementing the trait without adding a dependency to this crate in a third-party library.
sourcepub fn map<F, U: ?Sized>(self, f: F) -> OwningRef<O, U>where
O: StableAddress,
F: FnOnce(&mut T) -> &U,
pub fn map<F, U: ?Sized>(self, f: F) -> OwningRef<O, U>where
O: StableAddress,
F: FnOnce(&mut T) -> &U,
Converts self
into a new shared owning reference that points at
something reachable from the previous one.
This can be a reference to a field of U
, something reachable from a field of
U
, or even something unrelated with a 'static
lifetime.
Example
use rustc_data_structures::owning_ref::OwningRefMut;
fn main() {
let owning_ref_mut = OwningRefMut::new(Box::new([1, 2, 3, 4]));
// create an owning reference that points at the
// third element of the array.
let owning_ref = owning_ref_mut.map(|array| &array[2]);
assert_eq!(*owning_ref, 3);
}
sourcepub fn map_mut<F, U: ?Sized>(self, f: F) -> OwningRefMut<O, U>where
O: StableAddress,
F: FnOnce(&mut T) -> &mut U,
pub fn map_mut<F, U: ?Sized>(self, f: F) -> OwningRefMut<O, U>where
O: StableAddress,
F: FnOnce(&mut T) -> &mut U,
Converts self
into a new mutable owning reference that points at
something reachable from the previous one.
This can be a reference to a field of U
, something reachable from a field of
U
, or even something unrelated with a 'static
lifetime.
Example
use rustc_data_structures::owning_ref::OwningRefMut;
fn main() {
let owning_ref_mut = OwningRefMut::new(Box::new([1, 2, 3, 4]));
// create an owning reference that points at the
// third element of the array.
let owning_ref_mut = owning_ref_mut.map_mut(|array| &mut array[2]);
assert_eq!(*owning_ref_mut, 3);
}
sourcepub fn try_map<F, U: ?Sized, E>(self, f: F) -> Result<OwningRef<O, U>, E>where
O: StableAddress,
F: FnOnce(&mut T) -> Result<&U, E>,
pub fn try_map<F, U: ?Sized, E>(self, f: F) -> Result<OwningRef<O, U>, E>where
O: StableAddress,
F: FnOnce(&mut T) -> Result<&U, E>,
Tries to convert self
into a new shared owning reference that points
at something reachable from the previous one.
This can be a reference to a field of U
, something reachable from a field of
U
, or even something unrelated with a 'static
lifetime.
Example
use rustc_data_structures::owning_ref::OwningRefMut;
fn main() {
let owning_ref_mut = OwningRefMut::new(Box::new([1, 2, 3, 4]));
// create an owning reference that points at the
// third element of the array.
let owning_ref = owning_ref_mut.try_map(|array| {
if array[2] == 3 { Ok(&array[2]) } else { Err(()) }
});
assert_eq!(*owning_ref.unwrap(), 3);
}
sourcepub fn try_map_mut<F, U: ?Sized, E>(self, f: F) -> Result<OwningRefMut<O, U>, E>where
O: StableAddress,
F: FnOnce(&mut T) -> Result<&mut U, E>,
pub fn try_map_mut<F, U: ?Sized, E>(self, f: F) -> Result<OwningRefMut<O, U>, E>where
O: StableAddress,
F: FnOnce(&mut T) -> Result<&mut U, E>,
Tries to convert self
into a new mutable owning reference that points
at something reachable from the previous one.
This can be a reference to a field of U
, something reachable from a field of
U
, or even something unrelated with a 'static
lifetime.
Example
use rustc_data_structures::owning_ref::OwningRefMut;
fn main() {
let owning_ref_mut = OwningRefMut::new(Box::new([1, 2, 3, 4]));
// create an owning reference that points at the
// third element of the array.
let owning_ref_mut = owning_ref_mut.try_map_mut(|array| {
if array[2] == 3 { Ok(&mut array[2]) } else { Err(()) }
});
assert_eq!(*owning_ref_mut.unwrap(), 3);
}
sourcepub unsafe fn map_owner<F, P>(self, f: F) -> OwningRefMut<P, T>where
O: StableAddress,
P: StableAddress,
F: FnOnce(O) -> P,
pub unsafe fn map_owner<F, P>(self, f: F) -> OwningRefMut<P, T>where
O: StableAddress,
P: StableAddress,
F: FnOnce(O) -> P,
Converts self
into a new owning reference with a different owner type.
The new owner type needs to still contain the original owner in some way so that the reference into it remains valid. This function is marked unsafe because the user needs to manually uphold this guarantee.
sourcepub fn map_owner_box(self) -> OwningRefMut<Box<O>, T>
pub fn map_owner_box(self) -> OwningRefMut<Box<O>, T>
Converts self
into a new owning reference where the owner is wrapped
in an additional Box<O>
.
This can be used to safely erase the owner of any OwningRefMut<O, T>
to an OwningRefMut<Box<Erased>, T>
.
sourcepub fn erase_owner<'a>(self) -> OwningRefMut<O::Erased, T>where
O: IntoErased<'a>,
pub fn erase_owner<'a>(self) -> OwningRefMut<O::Erased, T>where
O: IntoErased<'a>,
Erases the concrete base type of the owner with a trait object.
This allows mixing of owned references with different owner base types.
Example
use rustc_data_structures::owning_ref::{OwningRefMut, Erased};
fn main() {
// N.B., using the concrete types here for explicitness.
// For less verbose code type aliases like `BoxRef` are provided.
let owning_ref_mut_a: OwningRefMut<Box<[i32; 4]>, [i32; 4]>
= OwningRefMut::new(Box::new([1, 2, 3, 4]));
let owning_ref_mut_b: OwningRefMut<Box<Vec<(i32, bool)>>, Vec<(i32, bool)>>
= OwningRefMut::new(Box::new(vec![(0, false), (1, true)]));
let owning_ref_mut_a: OwningRefMut<Box<[i32; 4]>, i32>
= owning_ref_mut_a.map_mut(|a| &mut a[0]);
let owning_ref_mut_b: OwningRefMut<Box<Vec<(i32, bool)>>, i32>
= owning_ref_mut_b.map_mut(|a| &mut a[1].0);
let owning_refs_mut: [OwningRefMut<Box<dyn Erased>, i32>; 2]
= [owning_ref_mut_a.erase_owner(), owning_ref_mut_b.erase_owner()];
assert_eq!(*owning_refs_mut[0], 1);
assert_eq!(*owning_refs_mut[1], 1);
}
sourcepub fn into_inner(self) -> O
pub fn into_inner(self) -> O
Discards the reference and retrieves the owner.
Trait Implementations§
source§impl<O, T: ?Sized> AsMut<T> for OwningRefMut<O, T>
impl<O, T: ?Sized> AsMut<T> for OwningRefMut<O, T>
source§impl<O, T: ?Sized> AsRef<T> for OwningRefMut<O, T>
impl<O, T: ?Sized> AsRef<T> for OwningRefMut<O, T>
source§impl<O, T: ?Sized> Deref for OwningRefMut<O, T>
impl<O, T: ?Sized> Deref for OwningRefMut<O, T>
source§impl<O, T: ?Sized> DerefMut for OwningRefMut<O, T>
impl<O, T: ?Sized> DerefMut for OwningRefMut<O, T>
source§impl<O, T: ?Sized> From<O> for OwningRefMut<O, T>where
O: StableAddress + DerefMut<Target = T>,
impl<O, T: ?Sized> From<O> for OwningRefMut<O, T>where
O: StableAddress + DerefMut<Target = T>,
source§impl<O, T: ?Sized> From<OwningRefMut<O, T>> for OwningRef<O, T>where
O: StableAddress + DerefMut<Target = T>,
impl<O, T: ?Sized> From<OwningRefMut<O, T>> for OwningRef<O, T>where
O: StableAddress + DerefMut<Target = T>,
source§fn from(other: OwningRefMut<O, T>) -> Self
fn from(other: OwningRefMut<O, T>) -> Self
source§impl<O, T> Ord for OwningRefMut<O, T>where
T: Ord + ?Sized,
impl<O, T> Ord for OwningRefMut<O, T>where
T: Ord + ?Sized,
source§impl<O, T> PartialEq<OwningRefMut<O, T>> for OwningRefMut<O, T>where
T: PartialEq + ?Sized,
impl<O, T> PartialEq<OwningRefMut<O, T>> for OwningRefMut<O, T>where
T: PartialEq + ?Sized,
source§impl<O, T> PartialOrd<OwningRefMut<O, T>> for OwningRefMut<O, T>where
T: PartialOrd + ?Sized,
impl<O, T> PartialOrd<OwningRefMut<O, T>> for OwningRefMut<O, T>where
T: PartialOrd + ?Sized,
1.0.0 · source§fn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
self
and other
) and is used by the <=
operator. Read moreimpl<O, T> Eq for OwningRefMut<O, T>where
T: Eq + ?Sized,
impl<O, T: ?Sized> Send for OwningRefMut<O, T>where
O: Send,
for<'a> &'a mut T: Send,
impl<O, T: ?Sized> Sync for OwningRefMut<O, T>where
O: Sync,
for<'a> &'a mut T: Sync,
Auto Trait Implementations§
impl<O, T: ?Sized> RefUnwindSafe for OwningRefMut<O, T>where
O: RefUnwindSafe,
T: RefUnwindSafe,
impl<O, T: ?Sized> Unpin for OwningRefMut<O, T>where
O: Unpin,
impl<O, T: ?Sized> UnwindSafe for OwningRefMut<O, T>where
O: UnwindSafe,
T: RefUnwindSafe,
Blanket Implementations§
impl<'a, T> Captures<'a> for Twhere
T: ?Sized,
impl<T> Erased for T
Layout§
Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.