# 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::Onwed`

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`

impl`Neg`

`&V`

impl`Neg`

- both have the same
`Output`

The `Not`

(`!`

prefix) op is implemented for `V`

if:

`V`

impl`Not`

`&V`

impl`Not`

- 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§

## Implementations§

source§### impl<'a, T> MaybeOwned<'a, T>

### impl<'a, T> MaybeOwned<'a, T>

source§### impl<'a, T> MaybeOwned<'a, T>where
T: Clone,

### impl<'a, T> MaybeOwned<'a, T>where
T: Clone,

source#### pub fn to_mut(&mut self) -> &mut T

#### pub fn to_mut(&mut self) -> &mut T

Aquires 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());
```

source#### pub fn into_owned(self) -> T

#### pub fn into_owned(self) -> T

Extracts the owned data.

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

## Trait Implementations§

source§### impl<'min, L, R, OUT: 'min> Add<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R, OUT: 'min> Add<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§### impl<'min, L, R> AddAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R> AddAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§#### fn add_assign(&mut self, rhs: MaybeOwned<'min, R>)

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

`+=`

operation. Read moresource§### impl<'a, T> AsRef<T> for MaybeOwned<'a, T>

### impl<'a, T> AsRef<T> for MaybeOwned<'a, T>

source§### impl<'min, L, R, OUT: 'min> BitAnd<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R, OUT: 'min> BitAnd<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§### impl<'min, L, R> BitAndAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R> BitAndAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§#### fn bitand_assign(&mut self, rhs: MaybeOwned<'min, R>)

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

`&=`

operation. Read moresource§### impl<'min, L, R, OUT: 'min> BitOr<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R, OUT: 'min> BitOr<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§### impl<'min, L, R> BitOrAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R> BitOrAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§#### fn bitor_assign(&mut self, rhs: MaybeOwned<'min, R>)

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

`|=`

operation. Read moresource§### impl<'min, L, R, OUT: 'min> BitXor<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R, OUT: 'min> BitXor<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§### impl<'min, L, R> BitXorAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R> BitXorAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§#### fn bitxor_assign(&mut self, rhs: MaybeOwned<'min, R>)

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

`^=`

operation. Read moresource§### impl<'a, T> Borrow<T> for MaybeOwned<'a, T>

### impl<'a, T> Borrow<T> for MaybeOwned<'a, T>

source§### impl<'a, T> Clone for MaybeOwned<'a, T>where
T: Clone,

### impl<'a, T> Clone for MaybeOwned<'a, T>where
T: Clone,

source§#### fn clone(&self) -> MaybeOwned<'a, T>

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

1.0.0 · source§#### fn clone_from(&mut self, source: &Self)

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

`source`

. Read moresource§### impl<'a, T: Debug + 'a> Debug for MaybeOwned<'a, T>

### impl<'a, T: Debug + 'a> Debug for MaybeOwned<'a, T>

source§### impl<'a, T> Default for MaybeOwned<'a, T>where
T: Default,

### impl<'a, T> Default for MaybeOwned<'a, T>where
T: Default,

source§### impl<'a, T> Deref for MaybeOwned<'a, T>

### impl<'a, T> Deref for MaybeOwned<'a, T>

source§### impl<'a, T> Display for MaybeOwned<'a, T>where
T: Display,

### impl<'a, T> Display for MaybeOwned<'a, T>where
T: Display,

source§### impl<'min, L, R, OUT: 'min> Div<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R, OUT: 'min> Div<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§### impl<'min, L, R> DivAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R> DivAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§#### fn div_assign(&mut self, rhs: MaybeOwned<'min, R>)

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

`/=`

operation. Read moresource§### impl<'a, T> From<&'a T> for MaybeOwned<'a, T>

### impl<'a, T> From<&'a T> for MaybeOwned<'a, T>

source§#### fn from(v: &'a T) -> MaybeOwned<'a, T>

#### fn from(v: &'a T) -> MaybeOwned<'a, T>

source§### impl<'a, T> From<Cow<'a, T>> for MaybeOwned<'a, T>where
T: ToOwned<Owned = T>,

### impl<'a, T> From<Cow<'a, T>> for MaybeOwned<'a, T>where
T: ToOwned<Owned = T>,

source§#### fn from(cow: Cow<'a, T>) -> MaybeOwned<'a, T>

#### fn from(cow: Cow<'a, T>) -> MaybeOwned<'a, T>

source§### impl<'a, T> From<T> for MaybeOwned<'a, T>

### impl<'a, T> From<T> for MaybeOwned<'a, T>

source§#### fn from(v: T) -> MaybeOwned<'a, T>

#### fn from(v: T) -> MaybeOwned<'a, T>

source§### impl<'a, T> FromStr for MaybeOwned<'a, T>where
T: FromStr,

### impl<'a, T> FromStr for MaybeOwned<'a, T>where
T: FromStr,

source§### impl<'a, T> Hash for MaybeOwned<'a, T>where
T: Hash,

### impl<'a, T> Hash for MaybeOwned<'a, T>where
T: Hash,

source§### impl<'min, L, R, OUT: 'min> Mul<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R, OUT: 'min> Mul<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§### impl<'min, L, R> MulAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R> MulAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§#### fn mul_assign(&mut self, rhs: MaybeOwned<'min, R>)

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

`*=`

operation. Read moresource§### impl<'l, V, OUT> Neg for MaybeOwned<'l, V>

### impl<'l, V, OUT> Neg for MaybeOwned<'l, V>

source§### impl<'l, V, OUT> Not for MaybeOwned<'l, V>

### impl<'l, V, OUT> Not for MaybeOwned<'l, V>

source§### impl<'a, T> Ord for MaybeOwned<'a, T>where
T: Ord,

### impl<'a, T> Ord for MaybeOwned<'a, T>where
T: Ord,

source§#### fn cmp(&self, other: &MaybeOwned<'a, T>) -> Ordering

#### fn cmp(&self, other: &MaybeOwned<'a, T>) -> Ordering

1.21.0 · source§#### fn max(self, other: Self) -> Selfwhere
Self: Sized,

#### fn max(self, other: Self) -> Selfwhere
Self: Sized,

source§### impl<'a, 'b, A, B> PartialEq<MaybeOwned<'b, B>> for MaybeOwned<'a, A>where
A: PartialEq<B>,

### impl<'a, 'b, A, B> PartialEq<MaybeOwned<'b, B>> for MaybeOwned<'a, A>where
A: PartialEq<B>,

source§#### fn eq(&self, other: &MaybeOwned<'b, B>) -> bool

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

`self`

and `other`

values to be equal, and is used
by `==`

.source§### impl<'a, T> PartialOrd for MaybeOwned<'a, T>where
T: PartialOrd,

### impl<'a, T> PartialOrd for MaybeOwned<'a, T>where
T: PartialOrd,

source§#### fn partial_cmp(&self, other: &MaybeOwned<'a, T>) -> Option<Ordering>

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

1.0.0 · source§#### fn le(&self, other: &Rhs) -> bool

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

`self`

and `other`

) and is used by the `<=`

operator. Read moresource§### impl<'min, L, R, OUT: 'min> Shl<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R, OUT: 'min> Shl<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§### impl<'min, L, R> ShlAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R> ShlAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§#### fn shl_assign(&mut self, rhs: MaybeOwned<'min, R>)

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

`<<=`

operation. Read moresource§### impl<'min, L, R, OUT: 'min> Shr<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R, OUT: 'min> Shr<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§### impl<'min, L, R> ShrAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R> ShrAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§#### fn shr_assign(&mut self, rhs: MaybeOwned<'min, R>)

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

`>>=`

operation. Read moresource§### impl<'min, L, R, OUT: 'min> Sub<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R, OUT: 'min> Sub<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§### impl<'min, L, R> SubAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

### impl<'min, L, R> SubAssign<MaybeOwned<'min, R>> for MaybeOwned<'min, L>

source§#### fn sub_assign(&mut self, rhs: MaybeOwned<'min, R>)

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

`-=`

operation. Read more### impl<'a, T> Eq for MaybeOwned<'a, T>where
T: Eq,

## Auto Trait Implementations§

### impl<'a, T> Freeze for MaybeOwned<'a, T>where
T: Freeze,

### impl<'a, T> RefUnwindSafe for MaybeOwned<'a, T>where
T: RefUnwindSafe,

### impl<'a, T> Send for MaybeOwned<'a, T>

### 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§

source§### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

### impl<T> BorrowMut<T> for Twhere
T: ?Sized,

source§#### fn borrow_mut(&mut self) -> &mut T

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

source§### impl<T> CloneToUninit for Twhere
T: Clone,

### impl<T> CloneToUninit for Twhere
T: Clone,

source§#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

#### default unsafe fn clone_to_uninit(&self, dst: *mut T)

`clone_to_uninit`

)