Enum maybe_owned::MaybeOwnedMut

pub enum MaybeOwnedMut<'a, T: 'a> {
    Owned(T),
    Borrowed(&'a mut T),
}

This type is basically the same as MaybeOwned, but works with mutable references.

Note that while you can se MaybeOwned as a alternative implementation for a Cow (Copy-On-Write) type this isn't really the case for MaybeOwnedMut as changing it will potentially change the source through the given &mut reference. For example the transitive add assign (+=) implementation for MaybeOwned does (need to) convert the given instance into a owned variant before using += on the contained type. But for MaybeOwnedMut it can directly use += on the &mut contained in the Borrowed variant!

Variants

Owned(T)

owns T

Borrowed(&'a mut T)

has a reference to T

Implementations

impl<'_, T> MaybeOwnedMut<'_, T>

pub fn is_owned(&self) -> bool

Returns true if the data is owned else false.

impl<'_, T: Clone> MaybeOwnedMut<'_, T>

pub fn into_owned(self) -> T

Return the contained data in it's owned form.

If it's borrowed this will clone it.

pub fn make_owned(&mut self) -> &mut T

Internally converts the type into it's owned variant.

Conversion from a reference to the owned variant is done by cloning.

This returns a &mut T and as such can be used to "unconditionally" get an &mut T. Be aware that while this works with both MaybeOwned and MaybeOwnedMut it also converts it to an owned variant in both cases. So while it's the best way to get a &mut T for MaybeOwned for MaybeOwnedMut it's preferable to use as_mut from AsMut.

Example

use maybe_owned::MaybeOwned;

#[derive(Clone, Debug, PartialEq, Eq)]
struct PseudoBigData(u8);

let data = PseudoBigData(12);

let mut maybe: MaybeOwned<PseudoBigData> = (&data).into();
assert_eq!(false, maybe.is_owned());

{
    let reference = maybe.make_owned();
    assert_eq!(&mut PseudoBigData(12), reference);
}
assert!(maybe.is_owned());

Trait Implementations

impl<'min, L, R, OUT: 'min> Add<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: Add<R, Output = OUT> + Add<&'min R, Output = OUT>,
    &'min L: Add<R, Output = OUT> + Add<&'min R, Output = OUT>, 

type Output = OUT

The resulting type after applying the + operator.

fn add(self, rhs: MaybeOwnedMut<'min, R>) -> Self::Output

Performs the + operation.

impl<'min, L, R> AddAssign<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: AddAssign<R> + AddAssign<&'min R>, 

fn add_assign(&mut self, rhs: MaybeOwnedMut<'min, R>)

Performs the += operation.

impl<'_, T> AsMut<T> for MaybeOwnedMut<'_, T>

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

Performs the conversion.

impl<'_, T> AsRef<T> for MaybeOwnedMut<'_, T>

fn as_ref(&self) -> &T

Performs the conversion.

impl<'min, L, R, OUT: 'min> BitAnd<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: BitAnd<R, Output = OUT> + BitAnd<&'min R, Output = OUT>,
    &'min L: BitAnd<R, Output = OUT> + BitAnd<&'min R, Output = OUT>, 

type Output = OUT

The resulting type after applying the & operator.

fn bitand(self, rhs: MaybeOwnedMut<'min, R>) -> Self::Output

Performs the & operation.

impl<'min, L, R> BitAndAssign<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: BitAndAssign<R> + BitAndAssign<&'min R>, 

fn bitand_assign(&mut self, rhs: MaybeOwnedMut<'min, R>)

Performs the &= operation.

impl<'min, L, R, OUT: 'min> BitOr<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: BitOr<R, Output = OUT> + BitOr<&'min R, Output = OUT>,
    &'min L: BitOr<R, Output = OUT> + BitOr<&'min R, Output = OUT>, 

type Output = OUT

The resulting type after applying the | operator.

fn bitor(self, rhs: MaybeOwnedMut<'min, R>) -> Self::Output

Performs the | operation.

impl<'min, L, R> BitOrAssign<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: BitOrAssign<R> + BitOrAssign<&'min R>, 

fn bitor_assign(&mut self, rhs: MaybeOwnedMut<'min, R>)

Performs the |= operation.

impl<'min, L, R, OUT: 'min> BitXor<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: BitXor<R, Output = OUT> + BitXor<&'min R, Output = OUT>,
    &'min L: BitXor<R, Output = OUT> + BitXor<&'min R, Output = OUT>, 

type Output = OUT

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: MaybeOwnedMut<'min, R>) -> Self::Output

Performs the ^ operation.

impl<'min, L, R> BitXorAssign<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: BitXorAssign<R> + BitXorAssign<&'min R>, 

fn bitxor_assign(&mut self, rhs: MaybeOwnedMut<'min, R>)

Performs the ^= operation.

impl<'_, T> Borrow<T> for MaybeOwnedMut<'_, T>

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<'_, T> BorrowMut<T> for MaybeOwnedMut<'_, T>

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

Mutably borrows from an owned value.

impl<'a, T: Debug + 'a> Debug for MaybeOwnedMut<'a, T>

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

Formats the value using the given formatter.

impl<'_, T: Default> Default for MaybeOwnedMut<'_, T>

fn default() -> Self

Returns the "default value" for a type.

impl<'_, T> Deref for MaybeOwnedMut<'_, T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<'_, T> DerefMut for MaybeOwnedMut<'_, T>

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

Mutably dereferences the value.

impl<'a, T: Display> Display for MaybeOwnedMut<'a, T>

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

Formats the value using the given formatter.

impl<'min, L, R, OUT: 'min> Div<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: Div<R, Output = OUT> + Div<&'min R, Output = OUT>,
    &'min L: Div<R, Output = OUT> + Div<&'min R, Output = OUT>, 

type Output = OUT

The resulting type after applying the / operator.

fn div(self, rhs: MaybeOwnedMut<'min, R>) -> Self::Output

Performs the / operation.

impl<'min, L, R> DivAssign<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: DivAssign<R> + DivAssign<&'min R>, 

fn div_assign(&mut self, rhs: MaybeOwnedMut<'min, R>)

Performs the /= operation.

impl<'a, T: Eq> Eq for MaybeOwnedMut<'a, T>

impl<'a, T> From<&'a mut T> for MaybeOwnedMut<'a, T>

fn from(v: &'a mut T) -> Self

Performs the conversion.

impl<'_, T> From<T> for MaybeOwnedMut<'_, T>

fn from(v: T) -> Self

Performs the conversion.

impl<'_, T: FromStr> FromStr for MaybeOwnedMut<'_, T>

type Err = T::Err

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<'_, T: Hash> Hash for MaybeOwnedMut<'_, 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, 

Feeds a slice of this type into the given [Hasher].

impl<'min, L, R, OUT: 'min> Mul<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: Mul<R, Output = OUT> + Mul<&'min R, Output = OUT>,
    &'min L: Mul<R, Output = OUT> + Mul<&'min R, Output = OUT>, 

type Output = OUT

The resulting type after applying the * operator.

fn mul(self, rhs: MaybeOwnedMut<'min, R>) -> Self::Output

Performs the * operation.

impl<'min, L, R> MulAssign<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: MulAssign<R> + MulAssign<&'min R>, 

fn mul_assign(&mut self, rhs: MaybeOwnedMut<'min, R>)

Performs the *= operation.

impl<'l, V, OUT> Neg for MaybeOwnedMut<'l, V> where
    V: Neg<Output = OUT>,
    &'l V: Neg<Output = OUT>, 

type Output = OUT

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<'l, V, OUT> Not for MaybeOwnedMut<'l, V> where
    V: Not<Output = OUT>,
    &'l V: Not<Output = OUT>, 

type Output = V::Output

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<'_, T: Ord> Ord for MaybeOwnedMut<'_, T>

fn cmp(&self, other: &Self) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl<'b, '_, A: PartialEq<B>, B> PartialEq<MaybeOwnedMut<'b, B>> for MaybeOwnedMut<'_, A>

fn eq(&self, other: &MaybeOwnedMut<'b, B>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<'_, T: PartialOrd> PartialOrd<MaybeOwnedMut<'_, T>> for MaybeOwnedMut<'_, T>

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

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

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

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

impl<'min, L, R, OUT: 'min> Shl<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: Shl<R, Output = OUT> + Shl<&'min R, Output = OUT>,
    &'min L: Shl<R, Output = OUT> + Shl<&'min R, Output = OUT>, 

type Output = OUT

The resulting type after applying the << operator.

fn shl(self, rhs: MaybeOwnedMut<'min, R>) -> Self::Output

Performs the << operation.

impl<'min, L, R> ShlAssign<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: ShlAssign<R> + ShlAssign<&'min R>, 

fn shl_assign(&mut self, rhs: MaybeOwnedMut<'min, R>)

Performs the <<= operation.

impl<'min, L, R, OUT: 'min> Shr<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: Shr<R, Output = OUT> + Shr<&'min R, Output = OUT>,
    &'min L: Shr<R, Output = OUT> + Shr<&'min R, Output = OUT>, 

type Output = OUT

The resulting type after applying the >> operator.

fn shr(self, rhs: MaybeOwnedMut<'min, R>) -> Self::Output

Performs the >> operation.

impl<'min, L, R> ShrAssign<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: ShrAssign<R> + ShrAssign<&'min R>, 

fn shr_assign(&mut self, rhs: MaybeOwnedMut<'min, R>)

Performs the >>= operation.

impl<'min, L, R, OUT: 'min> Sub<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: Sub<R, Output = OUT> + Sub<&'min R, Output = OUT>,
    &'min L: Sub<R, Output = OUT> + Sub<&'min R, Output = OUT>, 

type Output = OUT

The resulting type after applying the - operator.

fn sub(self, rhs: MaybeOwnedMut<'min, R>) -> Self::Output

Performs the - operation.

impl<'min, L, R> SubAssign<MaybeOwnedMut<'min, R>> for MaybeOwnedMut<'min, L> where
    L: SubAssign<R> + SubAssign<&'min R>, 

fn sub_assign(&mut self, rhs: MaybeOwnedMut<'min, R>)

Performs the -= operation.