Enum 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

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

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

fn as_ref(&self) -> &T

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

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> From<&'a mut T> for MaybeOwnedMut<'a, T>

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

Converts to this type from the input type.

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

fn from(v: T) -> Self

Converts to this type from the input type.

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

type Err = <T as FromStr>::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, Self: Sized,

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 as Not>::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.

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<'b, A: PartialEq<B>, B> PartialEq<MaybeOwnedMut<'b, B>> for MaybeOwnedMut<'_, A>

fn eq(&self, other: &MaybeOwnedMut<'b, B>) -> 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<T: PartialOrd> PartialOrd for MaybeOwnedMut<'_, T>

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

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