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.

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

Extracts the owned data.

If the data is borrowed it is cloned before being extracted.

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<'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.