Struct EntityMut 

pub struct EntityMut<'b, T: ?Sized> { /* private fields */ }

A guard that provides exclusive access to an IR entity

Implementations

impl<'b, T: ?Sized> EntityMut<'b, T>

pub fn map<U: ?Sized, F>(orig: Self, f: F) -> EntityMut<'b, U>

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

Map this mutable reference to a derived mutable reference.

pub fn project<'to, 'from: 'to, To, F>( orig: EntityMut<'from, T>, f: F, ) -> EntityProjectionMut<'from, To>

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

Project this mutable borrow into a owned (but semantically borrowed) value that inherits ownership of the underlying mutable borrow.

pub fn map_split<U: ?Sized, V: ?Sized, F>( orig: Self, f: F, ) -> (EntityMut<'b, U>, EntityMut<'b, V>)

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

Splits an EntityMut into multiple EntityMuts for different components of the borrowed data.

The underlying entity will remain mutably borrowed until both returned EntityMuts go out of scope.

The entity is already mutably borrowed, so this cannot fail.

This is an associated function that needs to be used as EntityMut::map_split(...), so as to avoid conflicting with any method of the same name accessible via the Deref impl.

Examples

use midenc_hir::*;
use blink_alloc::Blink;

let alloc = Blink::default();
let mut entity = UnsafeEntityRef::new([1, 2, 3, 4], &alloc);
let borrow = entity.borrow_mut();
let (mut begin, mut end) = EntityMut::map_split(borrow, |slice| slice.split_at_mut(2));
assert_eq!(*begin, [1, 2]);
assert_eq!(*end, [3, 4]);
begin.copy_from_slice(&[4, 3]);
end.copy_from_slice(&[2, 1]);

pub fn into_entity_ref(self) -> EntityRef<'b, T>

Convert this mutable borrow into an immutable borrow

Trait Implementations

impl<'b, T, U> CoerceUnsized<EntityMut<'b, U>> for EntityMut<'b, T>

where T: ?Sized + Unsize<U>, U: ?Sized,

impl<T: ?Sized + Debug> Debug for EntityMut<'_, T>

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

Formats the value using the given formatter.

impl<T: ?Sized> Deref for EntityMut<'_, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: ?Sized> DerefMut for EntityMut<'_, T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<T: ?Sized + Display> Display for EntityMut<'_, T>

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

Formats the value using the given formatter.

impl<T: ?Sized + Eq> Eq for EntityMut<'_, T>

impl<T> From<EntityMut<'_, T>> for ProgramPoint

where for<'a> ProgramPoint: From<&'a T>,

fn from(entity: EntityMut<'_, T>) -> Self

Converts to this type from the input type.

impl<T: ?Sized + Hash> Hash for EntityMut<'_, T>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: ?Sized + Ord> Ord for EntityMut<'_, T>

fn cmp(&self, other: &Self) -> 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,

Restrict a value to a certain interval.

impl<T: ?Sized + PartialEq> PartialEq for EntityMut<'_, T>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<'a, T: ?Sized + PartialEq + AsAny + 'static> PartialEqable for EntityMut<'a, T>

fn equable_type_name(&self) -> &'static str

fn eqable(&self) -> &dyn Any

impl<T: ?Sized + PartialOrd> PartialOrd for EntityMut<'_, T>

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

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

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

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

Tests less than (for self and other) and is used by the < operator.

impl<T: ?Sized + PrettyPrint> PrettyPrint for EntityMut<'_, T>

fn render(&self) -> Document

The core of the PrettyPrint functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.