Enum maybe_owned::MaybeOwned
source · [−]pub enum MaybeOwned<'a, T: 'a> {
Owned(T),
Borrowed(&'a T),
}
Expand description
This type provides a way to store data to which you either have a reference to or which you do own.
It provides From<T>
, From<&'a T>
implementations and, in difference
to Cow
does not require ToOwned
to be implemented which makes it
compatible with non cloneable data, as a draw back of this it does not
know about ToOwned
. As a consequence of it can’t know that &str
should
be the borrowed version of String
and not &String
this is especially
bad wrt. Box
as the borrowed version of Box<T>
would be &Box<T>
.
While this crate has some drawbacks compared to Cow
is has the benefit,
that it works with Types which neither implement Clone
nor ToOwned
.
Another benefit lies in the ability to write API functions which accept
a generic parameter E: Into<MaybeOwned<'a, T>>
as the API consumer can
pass T
, &'a T
and MaybeOwned<'a, T>
as argument, without requiring
a explicit Cow::Owned
or a split into two functions one accepting
owed and the other borrowed values.
Alternatives
If you mainly have values implementing ToOwned
like &str
/String
, Path
/PathBuf
or
&[T]
/Vec<T>
using std::borrow::Cow
might be preferable.
If you want to be able to treat &T
, &mut T
, Box<T>
and Arc<T>
the same
consider using reffers::rbma::RBMA
(through not all types/platforms are supported because
as it relies on the fact that for many pointers the lowest two bits are 0, and stores
the discriminant in them, nevertheless this is can only be used with 32bit-aligned data,
e.g. using a &u8 might fail). RBMA also allows you to recover a &mut T
if it was created
from Box<T>
, &mut T
or a unique Arc
.
Examples
struct PseudoBigData(u8);
fn pseudo_register_fn<'a, E>(_val: E) where E: Into<MaybeOwned<'a, PseudoBigData>> { }
let data = PseudoBigData(12);
let data2 = PseudoBigData(13);
pseudo_register_fn(&data);
pseudo_register_fn(&data);
pseudo_register_fn(data2);
pseudo_register_fn(MaybeOwned::Owned(PseudoBigData(111)));
#[repr(C)]
struct OpaqueFFI {
ref1: * const u8
//we also might want to have PhantomData etc.
}
// does not work as it does not implement `ToOwned`
// let _ = Cow::Owned(OpaqueFFI { ref1: 0 as *const u8});
// ok, MaybeOwned can do this (but can't do &str<->String as tread of)
let _ = MaybeOwned::Owned(OpaqueFFI { ref1: 0 as *const u8 });
use std::collections::HashMap;
#[derive(Serialize, Deserialize)]
struct SerializedData<'a> {
data: MaybeOwned<'a, HashMap<String, i32>>,
}
let mut map = HashMap::new();
map.insert("answer".to_owned(), 42);
// serializing can use borrowed data to avoid unnecessary copying
let bytes = serde_json::to_vec(&SerializedData { data: (&map).into() }).unwrap();
// deserializing creates owned data
let deserialized: SerializedData = serde_json::from_slice(&bytes).unwrap();
assert_eq!(deserialized.data["answer"], 42);
Transitive std::ops
implementations
There are transitive implementations for most operator in std::ops
.
A Op between a MaybeOwned<L>
and MaybeOwned<R>
is implemented if:
- L impl the Op with R
- L impl the Op with &R
- &L impl the Op with R
- &L impl the Op with &R
- the
Output
of all aboves implementations is the same type
The Neg
(-
prefix) op is implemented for V
if:
V
implNeg
&V
implNeg
- both have the same
Output
The Not
(!
prefix) op is implemented for V
if:
V
implNot
&V
implNot
- both have the same
Output
Adding implementations for Ops which add a MaybeOwned
to
a non MaybeOwned
value (like MaybeOwned<T> + T
) requires
far reaching specialization in rust and is therefore not done
for now.
Variants
Owned(T)
owns T
Borrowed(&'a T)
has a reference to T
Implementations
sourceimpl<T> MaybeOwned<'_, T>
impl<T> MaybeOwned<'_, T>
sourceimpl<T: Clone> MaybeOwned<'_, T>
impl<T: Clone> MaybeOwned<'_, T>
sourcepub fn into_owned(self) -> T
pub fn into_owned(self) -> T
Return the contained data in it’s owned form.
If it’s borrowed this will clone it.
sourcepub fn make_owned(&mut self) -> &mut T
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());
sourceimpl<T> MaybeOwned<'_, T>
impl<T> MaybeOwned<'_, T>
sourceimpl<T: Clone> MaybeOwned<'_, T>
impl<T: Clone> MaybeOwned<'_, T>
sourcepub fn to_mut(&mut self) -> &mut T
👎 Deprecated: use make_owned
instead
pub fn to_mut(&mut self) -> &mut T
use make_owned
instead
Acquires a mutable reference to owned data.
Clones data if it is not already owned.
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.to_mut();
assert_eq!(&mut PseudoBigData(12), reference);
}
assert!(maybe.is_owned());
Trait Implementations
sourceimpl<'min, L, R, OUT: 'min> Add<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Add<R, Output = OUT> + Add<&'min R, Output = OUT>,
&'min L: Add<R, Output = OUT> + Add<&'min R, Output = OUT>,
impl<'min, L, R, OUT: 'min> Add<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Add<R, Output = OUT> + Add<&'min R, Output = OUT>,
&'min L: Add<R, Output = OUT> + Add<&'min R, Output = OUT>,
sourceimpl<'min, L, R> AddAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + AddAssign<R> + AddAssign<&'min R>,
impl<'min, L, R> AddAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + AddAssign<R> + AddAssign<&'min R>,
sourcefn add_assign(&mut self, rhs: MaybeOwned<'min, R>)
fn add_assign(&mut self, rhs: MaybeOwned<'min, R>)
Performs the +=
operation. Read more
sourceimpl<'min, L, R, OUT: 'min> BitAnd<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: BitAnd<R, Output = OUT> + BitAnd<&'min R, Output = OUT>,
&'min L: BitAnd<R, Output = OUT> + BitAnd<&'min R, Output = OUT>,
impl<'min, L, R, OUT: 'min> BitAnd<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: BitAnd<R, Output = OUT> + BitAnd<&'min R, Output = OUT>,
&'min L: BitAnd<R, Output = OUT> + BitAnd<&'min R, Output = OUT>,
sourceimpl<'min, L, R> BitAndAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + BitAndAssign<R> + BitAndAssign<&'min R>,
impl<'min, L, R> BitAndAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + BitAndAssign<R> + BitAndAssign<&'min R>,
sourcefn bitand_assign(&mut self, rhs: MaybeOwned<'min, R>)
fn bitand_assign(&mut self, rhs: MaybeOwned<'min, R>)
Performs the &=
operation. Read more
sourceimpl<'min, L, R, OUT: 'min> BitOr<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: BitOr<R, Output = OUT> + BitOr<&'min R, Output = OUT>,
&'min L: BitOr<R, Output = OUT> + BitOr<&'min R, Output = OUT>,
impl<'min, L, R, OUT: 'min> BitOr<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: BitOr<R, Output = OUT> + BitOr<&'min R, Output = OUT>,
&'min L: BitOr<R, Output = OUT> + BitOr<&'min R, Output = OUT>,
sourceimpl<'min, L, R> BitOrAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + BitOrAssign<R> + BitOrAssign<&'min R>,
impl<'min, L, R> BitOrAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + BitOrAssign<R> + BitOrAssign<&'min R>,
sourcefn bitor_assign(&mut self, rhs: MaybeOwned<'min, R>)
fn bitor_assign(&mut self, rhs: MaybeOwned<'min, R>)
Performs the |=
operation. Read more
sourceimpl<'min, L, R, OUT: 'min> BitXor<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: BitXor<R, Output = OUT> + BitXor<&'min R, Output = OUT>,
&'min L: BitXor<R, Output = OUT> + BitXor<&'min R, Output = OUT>,
impl<'min, L, R, OUT: 'min> BitXor<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: BitXor<R, Output = OUT> + BitXor<&'min R, Output = OUT>,
&'min L: BitXor<R, Output = OUT> + BitXor<&'min R, Output = OUT>,
sourceimpl<'min, L, R> BitXorAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + BitXorAssign<R> + BitXorAssign<&'min R>,
impl<'min, L, R> BitXorAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + BitXorAssign<R> + BitXorAssign<&'min R>,
sourcefn bitxor_assign(&mut self, rhs: MaybeOwned<'min, R>)
fn bitxor_assign(&mut self, rhs: MaybeOwned<'min, R>)
Performs the ^=
operation. Read more
sourceimpl<T> Borrow<T> for MaybeOwned<'_, T>
impl<T> Borrow<T> for MaybeOwned<'_, T>
sourceimpl<T: Clone> Clone for MaybeOwned<'_, T>
impl<T: Clone> Clone for MaybeOwned<'_, T>
sourceimpl<'a, T: Debug + 'a> Debug for MaybeOwned<'a, T>
impl<'a, T: Debug + 'a> Debug for MaybeOwned<'a, T>
sourceimpl<T: Default> Default for MaybeOwned<'_, T>
impl<T: Default> Default for MaybeOwned<'_, T>
sourceimpl<T> Deref for MaybeOwned<'_, T>
impl<T> Deref for MaybeOwned<'_, T>
sourceimpl<'a, T: Display> Display for MaybeOwned<'a, T>
impl<'a, T: Display> Display for MaybeOwned<'a, T>
sourceimpl<'min, L, R, OUT: 'min> Div<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Div<R, Output = OUT> + Div<&'min R, Output = OUT>,
&'min L: Div<R, Output = OUT> + Div<&'min R, Output = OUT>,
impl<'min, L, R, OUT: 'min> Div<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Div<R, Output = OUT> + Div<&'min R, Output = OUT>,
&'min L: Div<R, Output = OUT> + Div<&'min R, Output = OUT>,
sourceimpl<'min, L, R> DivAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + DivAssign<R> + DivAssign<&'min R>,
impl<'min, L, R> DivAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + DivAssign<R> + DivAssign<&'min R>,
sourcefn div_assign(&mut self, rhs: MaybeOwned<'min, R>)
fn div_assign(&mut self, rhs: MaybeOwned<'min, R>)
Performs the /=
operation. Read more
sourceimpl<'a, T> From<&'a T> for MaybeOwned<'a, T>
impl<'a, T> From<&'a T> for MaybeOwned<'a, T>
sourceimpl<'a, T: ToOwned<Owned = T>> From<Cow<'a, T>> for MaybeOwned<'a, T>
impl<'a, T: ToOwned<Owned = T>> From<Cow<'a, T>> for MaybeOwned<'a, T>
sourcefn from(cow: Cow<'a, T>) -> MaybeOwned<'a, T>
fn from(cow: Cow<'a, T>) -> MaybeOwned<'a, T>
Performs the conversion.
sourceimpl<T> From<T> for MaybeOwned<'_, T>
impl<T> From<T> for MaybeOwned<'_, T>
sourceimpl<T: FromStr> FromStr for MaybeOwned<'_, T>
impl<T: FromStr> FromStr for MaybeOwned<'_, T>
sourceimpl<T: Hash> Hash for MaybeOwned<'_, T>
impl<T: Hash> Hash for MaybeOwned<'_, T>
sourceimpl<'a, T: ToOwned<Owned = T>> Into<Cow<'a, T>> for MaybeOwned<'a, T>
impl<'a, T: ToOwned<Owned = T>> Into<Cow<'a, T>> for MaybeOwned<'a, T>
sourceimpl<'min, L, R, OUT: 'min> Mul<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Mul<R, Output = OUT> + Mul<&'min R, Output = OUT>,
&'min L: Mul<R, Output = OUT> + Mul<&'min R, Output = OUT>,
impl<'min, L, R, OUT: 'min> Mul<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Mul<R, Output = OUT> + Mul<&'min R, Output = OUT>,
&'min L: Mul<R, Output = OUT> + Mul<&'min R, Output = OUT>,
sourceimpl<'min, L, R> MulAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + MulAssign<R> + MulAssign<&'min R>,
impl<'min, L, R> MulAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + MulAssign<R> + MulAssign<&'min R>,
sourcefn mul_assign(&mut self, rhs: MaybeOwned<'min, R>)
fn mul_assign(&mut self, rhs: MaybeOwned<'min, R>)
Performs the *=
operation. Read more
sourceimpl<'l, V, OUT> Neg for MaybeOwned<'l, V> where
V: Neg<Output = OUT>,
&'l V: Neg<Output = OUT>,
impl<'l, V, OUT> Neg for MaybeOwned<'l, V> where
V: Neg<Output = OUT>,
&'l V: Neg<Output = OUT>,
sourceimpl<'l, V, OUT> Not for MaybeOwned<'l, V> where
V: Not<Output = OUT>,
&'l V: Not<Output = OUT>,
impl<'l, V, OUT> Not for MaybeOwned<'l, V> where
V: Not<Output = OUT>,
&'l V: Not<Output = OUT>,
sourceimpl<T: Ord> Ord for MaybeOwned<'_, T>
impl<T: Ord> Ord for MaybeOwned<'_, T>
sourceimpl<'b, A: PartialEq<B>, B> PartialEq<MaybeOwned<'b, B>> for MaybeOwned<'_, A>
impl<'b, A: PartialEq<B>, B> PartialEq<MaybeOwned<'b, B>> for MaybeOwned<'_, A>
sourceimpl<T: PartialOrd> PartialOrd<MaybeOwned<'_, T>> for MaybeOwned<'_, T>
impl<T: PartialOrd> PartialOrd<MaybeOwned<'_, T>> for MaybeOwned<'_, T>
sourcefn partial_cmp(&self, other: &Self) -> Option<Ordering>
fn partial_cmp(&self, other: &Self) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
sourceimpl<'min, L, R, OUT: 'min> Shl<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Shl<R, Output = OUT> + Shl<&'min R, Output = OUT>,
&'min L: Shl<R, Output = OUT> + Shl<&'min R, Output = OUT>,
impl<'min, L, R, OUT: 'min> Shl<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Shl<R, Output = OUT> + Shl<&'min R, Output = OUT>,
&'min L: Shl<R, Output = OUT> + Shl<&'min R, Output = OUT>,
sourceimpl<'min, L, R> ShlAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + ShlAssign<R> + ShlAssign<&'min R>,
impl<'min, L, R> ShlAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + ShlAssign<R> + ShlAssign<&'min R>,
sourcefn shl_assign(&mut self, rhs: MaybeOwned<'min, R>)
fn shl_assign(&mut self, rhs: MaybeOwned<'min, R>)
Performs the <<=
operation. Read more
sourceimpl<'min, L, R, OUT: 'min> Shr<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Shr<R, Output = OUT> + Shr<&'min R, Output = OUT>,
&'min L: Shr<R, Output = OUT> + Shr<&'min R, Output = OUT>,
impl<'min, L, R, OUT: 'min> Shr<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Shr<R, Output = OUT> + Shr<&'min R, Output = OUT>,
&'min L: Shr<R, Output = OUT> + Shr<&'min R, Output = OUT>,
sourceimpl<'min, L, R> ShrAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + ShrAssign<R> + ShrAssign<&'min R>,
impl<'min, L, R> ShrAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + ShrAssign<R> + ShrAssign<&'min R>,
sourcefn shr_assign(&mut self, rhs: MaybeOwned<'min, R>)
fn shr_assign(&mut self, rhs: MaybeOwned<'min, R>)
Performs the >>=
operation. Read more
sourceimpl<'min, L, R, OUT: 'min> Sub<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Sub<R, Output = OUT> + Sub<&'min R, Output = OUT>,
&'min L: Sub<R, Output = OUT> + Sub<&'min R, Output = OUT>,
impl<'min, L, R, OUT: 'min> Sub<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Sub<R, Output = OUT> + Sub<&'min R, Output = OUT>,
&'min L: Sub<R, Output = OUT> + Sub<&'min R, Output = OUT>,
sourceimpl<'min, L, R> SubAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + SubAssign<R> + SubAssign<&'min R>,
impl<'min, L, R> SubAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L> where
L: Clone + SubAssign<R> + SubAssign<&'min R>,
sourcefn sub_assign(&mut self, rhs: MaybeOwned<'min, R>)
fn sub_assign(&mut self, rhs: MaybeOwned<'min, R>)
Performs the -=
operation. Read more
impl<'a, T: Eq> Eq for MaybeOwned<'a, T>
Auto Trait Implementations
impl<'a, T> RefUnwindSafe for MaybeOwned<'a, T> where
T: RefUnwindSafe,
impl<'a, T> Send for MaybeOwned<'a, T> where
T: Send + Sync,
impl<'a, T> Sync for MaybeOwned<'a, T> where
T: Sync,
impl<'a, T> Unpin for MaybeOwned<'a, T> where
T: Unpin,
impl<'a, T> UnwindSafe for MaybeOwned<'a, T> where
T: UnwindSafe + RefUnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more