Struct Mut

pub struct Mut<T: ?Sized> { /* private fields */ }

A strong owned mutable reference to the given type that can be safely dereferenced.

Examples

Constructed from a static value:

use rune::Mut;

let value: Mut<[u8]> = Mut::from_static(&mut [][..]);
assert_eq!(&value[..], b"");

Implementations

impl<T: ?Sized> Mut<T>

pub fn from_static(value: &'static mut T) -> Mut<T>

Construct an owned mutable reference from a static value.

Examples

use rune::Mut;

let value: Mut<[u8]> = Mut::from_static(&mut [][..]);
assert_eq!(&value[..], b"");

pub fn map<U: ?Sized, F>(this: Self, f: F) -> Mut<U>

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

Map the interior reference of an owned mutable value.

Examples

use rune::Mut;
use rune::runtime::Bytes;
use rune::alloc::try_vec;

let bytes = rune::to_value(Bytes::from_vec(try_vec![1, 2, 3, 4]))?;
let bytes: Mut<Bytes> = rune::from_value(bytes)?;
let value: Mut<[u8]> = Mut::map(bytes, |bytes| &mut bytes[0..2]);

assert_eq!(&*value, &mut [1, 2][..]);

pub fn try_map<U: ?Sized, F>(this: Self, f: F) -> Result<Mut<U>, Mut<T>>

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

Try to map the mutable reference to a projection.

Examples

use rune::Mut;
use rune::runtime::Bytes;
use rune::alloc::try_vec;

let bytes = rune::to_value(Bytes::from_vec(try_vec![1, 2, 3, 4]))?;
let bytes: Mut<Bytes> = rune::from_value(bytes)?;

let Ok(mut value) = Mut::try_map(bytes, |bytes| bytes.get_mut(0..2)) else {
    panic!("Conversion failed");
};

assert_eq!(&mut value[..], &mut [1, 2][..]);

pub fn into_raw(this: Self) -> (NonNull<T>, RawAnyGuard)

Convert into a raw pointer and associated raw access guard.

Safety

The returned pointer must not outlive the associated guard, since this prevents other uses of the underlying data which is incompatible with the current.

pub unsafe fn from_raw(value: NonNull<T>, guard: RawAnyGuard) -> Self

Convert a raw mutable reference and guard into a regular mutable reference.

Safety

The caller is responsible for ensuring that the raw mutable reference is associated with the specific pointer.

Trait Implementations

impl<T: ?Sized> AsMut<T> for Mut<T>

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<T: ?Sized> AsRef<T> for Mut<T>

fn as_ref(&self) -> &T

Converts this type into a shared reference of the (usually inferred) input type.

impl<T> Debug for Mut<T>

where T: Debug + ?Sized,

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

Formats the value using the given formatter.

impl<T: ?Sized> Deref for Mut<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T: ?Sized> DerefMut for Mut<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T> FromValue for Mut<T>

where T: AnyMarker,

fn from_value(value: Value) -> Result<Self, RuntimeError>

Try to convert to the given type, from the given value.

impl FromValue for Mut<Tuple>

fn from_value(value: Value) -> Result<Self, RuntimeError>

Try to convert to the given type, from the given value.

impl<F> Future for Mut<F>

where F: Unpin + Future,

type Output = <F as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempts to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<T> MaybeTypeOf for Mut<T>

where T: ?Sized + MaybeTypeOf,

fn maybe_type_of() -> Result<DocType>

Type information for the given type.

impl<T> TypeHash for Mut<T>

where T: ?Sized + TypeHash,

Blanket implementation for owned mutable references.

const HASH: Hash = T::HASH

The complete type hash of the type including type parameters which uniquely identifiers a given type.

impl<T> TypeOf for Mut<T>

where T: ?Sized + TypeOf,

Blanket implementation for owned mutable references.

const PARAMETERS: Hash = T::PARAMETERS

Type parameters for the type.

const STATIC_TYPE_INFO: AnyTypeInfo = T::STATIC_TYPE_INFO

Access diagnostical type information for the current type.

fn type_info() -> TypeInfo

Get type info associated with the current type.