Struct TempInstMut

pub struct TempInstMut<'a, T: TempReprMutChk + 'a>(/* private fields */);

A wrapper around an instance of T which implements TempReprMut, i.e. is a temporary representation of a type T::Mutable<'a>.

TempInstMut itself has a lifetime parameter 'a and borrows the object passed to TempInstMut::new for that lifetime; therefore it is logically equivalent to T::Mutable<'a>. However, it can hand out references to the lifetime-less type T via its DerefMut implementation.

Implementations

impl<'a, T: TempReprMutChk> TempInstMut<'a, T>

pub unsafe fn new(obj: T::Mutable<'a>) -> Self

Creates a TempInstMut from an instance of T::Mutable.

A mutable reference to T can be obtained from the result via DerefMut.

As this method is unsafe, using one of the safe alternatives is strongly recommended:

• TempInstPin::new if a pinned mutable reference to T is sufficient.
• TempInstMut::call_with if the use of the mutable T reference can be confined to a closure.

TempInstMut::new potentially has a slight overhead compared to TempInstPin::new, in terms of both time and space, though there is a good chance that the compiler will optimize both away if it can analyze how the instance is used.

Safety

The caller must ensure at least one of the following two conditions.

• The Drop implementation of TempInstMut is called whenever the returned instance goes out of scope. (In particular, the instance must not be passed to core::mem::forget.)
• The state of the instance when it goes out of scope is the same as when it was created. (This condition can be violated by calling core::mem::swap or a related function on the TempInstMut instance. When the instance goes out of scope after passing it to core::mem::swap, the other TempInstMut instance that it was swapped with can become dangling. Note that passing the result of Self::deref_mut to core::mem::swap is not unsafe, however.)
• 'a is 'static. (A TempInstMut instance with static lifetimes cannot become dangling.)

Panics

The Drop implementation of the returned instance calls std::process::abort (after calling the standard panic handler) if the instance has been modified, which is not possible via its API but can be achieved by swapping it with another instance, e.g. using core::mem::swap.

Unfortunately, a regular panic is insufficient in this case because it can be caught with std::panic::catch_unwind, and a dangling TempInstMut reference can then be obtained from the closure passed to std::panic::catch_unwind (safely, because unfortunately std::panic::UnwindSafe is not an unsafe trait – why?!!).

The panic behavior can be changed via set_modification_panic_fn.

Remarks

For many types, including TempRef, T::Mutable is actually the same as T::Shared. This can be useful when combining mutable and shared references in a tuple. E.g. T = (TempRefMut<U>, TempRef<V>) represents (&mut U, &V), and this is preserved by TempInstMut::new, whereas TempInst::new treats it as (&U, &V).

pub fn call_with<R>(obj: T::Mutable<'a>, f: impl FnOnce(&mut T) -> R) -> R

Calls f with a mutable reference to T constructed from obj, and returns the value returned by f.

This method is a simple (but safe) wrapper around Self::new, which potentially has a slight overhead. If possible, use TempInstPin::new (or TempInstPin::call_with) instead.

Panics

Calls std::process::abort if f modifies the internal state of the object that was passed to it. See Self::new for more information.

Trait Implementations

impl<'a, T: Clone + TempReprMutChk + 'a> Clone for TempInstMut<'a, T>

where T::SwapChkData: Clone, T::Mutable<'a>: Clone,

fn clone(&self) -> TempInstMut<'a, T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: TempReprMutChk + Debug> Debug for TempInstMut<'_, T>

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

Formats the value using the given formatter.

impl<T: TempReprMutChk<Mutable<'static>: Default>> Default for TempInstMut<'static, T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: TempReprMutChk> Deref for TempInstMut<'_, T>

type Target = T

The resulting type after dereferencing.

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

Dereferences the value.

impl<T: TempReprMutChk> DerefMut for TempInstMut<'_, T>

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

Mutably dereferences the value.

impl<T: TempReprMutChk + Display> Display for TempInstMut<'_, T>

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

Formats the value using the given formatter.

impl<T: TempReprMutChk> Drop for TempInstMut<'_, T>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a, T: Hash + TempReprMutChk + 'a> Hash for TempInstMut<'a, T>

where T::SwapChkData: Hash, T::Mutable<'a>: Hash,

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<'a, T: Ord + TempReprMutChk + 'a> Ord for TempInstMut<'a, T>

where T::SwapChkData: Ord, T::Mutable<'a>: Ord,

fn cmp(&self, other: &TempInstMut<'a, 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,

Restrict a value to a certain interval.

impl<'a, T: PartialEq + TempReprMutChk + 'a> PartialEq for TempInstMut<'a, T>

where T::SwapChkData: PartialEq, T::Mutable<'a>: PartialEq,

fn eq(&self, other: &TempInstMut<'a, T>) -> 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: PartialOrd + TempReprMutChk + 'a> PartialOrd for TempInstMut<'a, T>

where T::SwapChkData: PartialOrd, T::Mutable<'a>: PartialOrd,

fn partial_cmp(&self, other: &TempInstMut<'a, T>) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<'a, T: Eq + TempReprMutChk + 'a> Eq for TempInstMut<'a, T>

where T::SwapChkData: Eq, T::Mutable<'a>: Eq,

impl<'a, T: TempReprMutChk + 'a> StructuralPartialEq for TempInstMut<'a, T>