Enum OwnedOrRef 

pub enum OwnedOrRef<'a, T> {
    Borrowed(&'a T),
    Owned(T),
}

A owned-or-ref enum

Variants

Borrowed(&'a T)

Owned(T)

Implementations

impl<T> OwnedOrRef<'_, T>

pub fn into_owned(self) -> T

Trait Implementations

impl<'a, F> Archive for OwnedOrRef<'a, F>

where F: Archive,

type Archived = ArchivedOwnedOrRef<F>

The archived representation of this type.

type Resolver = OwnedOrRefResolver<F>

The resolver for this type. It must contain all the additional information from serializing needed to make the archived type from the normal type.

fn resolve(&self, resolver: Self::Resolver, out: Place<Self::Archived>)

Creates the archived version of this value at the given position and writes it to the given output.

const COPY_OPTIMIZATION: CopyOptimization<Self> = _

An optimization flag that allows the bytes of this type to be copied directly to a writer instead of calling serialize.

impl<'a, T, F> ArchiveWith<OwnedOrRef<'a, F>> for AsOwned<T>

where T: ArchiveWith<F>,

type Archived = <T as ArchiveWith<F>>::Archived

The archived type of Self with F.

type Resolver = <T as ArchiveWith<F>>::Resolver

The resolver of a Self with F.

fn resolve_with( field: &OwnedOrRef<'_, F>, resolver: Self::Resolver, out: Place<Self::Archived>, )

Resolves the archived type using a reference to the field type F.

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

fn as_ref(&self) -> &T

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

impl<'a, T: Debug> Debug for OwnedOrRef<'a, T>

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

Formats the value using the given formatter.

impl<'a, F, D: Fallible + ?Sized> Deserialize<OwnedOrRef<'a, F>, D> for Archived<OwnedOrRef<'a, F>>

where F: Archive, <F as Archive>::Archived: Deserialize<F, D>,

fn deserialize( &self, deserializer: &mut D, ) -> Result<OwnedOrRef<'a, F>, <D as Fallible>::Error>

Deserializes using the given deserializer

impl<'a, T, F, D> DeserializeWith<<T as ArchiveWith<F>>::Archived, OwnedOrRef<'a, F>, D> for AsOwned<T>

where T: ArchiveWith<F> + DeserializeWith<T::Archived, F, D>, D: Fallible + ?Sized,

fn deserialize_with( field: &T::Archived, d: &mut D, ) -> Result<OwnedOrRef<'a, F>, D::Error>

Deserializes the field type F using the given deserializer.

impl<'a, T> From<&'a T> for OwnedOrRef<'a, T>

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

Converts to this type from the input type.

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

fn from(value: T) -> Self

Converts to this type from the input type.

impl<'a, 'b, A, B> PartialEq<OwnedOrRef<'a, A>> for OwnedOrRef<'b, B>

where B: PartialEq<A>,

fn eq(&self, other: &OwnedOrRef<'a, A>) -> 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<'a, F, S: Fallible + ?Sized> Serialize<S> for OwnedOrRef<'a, F>

where F: Serialize<S>,

fn serialize( &self, serializer: &mut S, ) -> Result<<Self as Archive>::Resolver, <S as Fallible>::Error>

Writes the dependencies for the object and returns a resolver that can create the archived type.

impl<'a, T, F, S> SerializeWith<OwnedOrRef<'a, F>, S> for AsOwned<T>

where T: SerializeWith<F, S>, S: Fallible + ?Sized,

fn serialize_with( field: &OwnedOrRef<'_, F>, s: &mut S, ) -> Result<Self::Resolver, S::Error>

Serializes the field type F using the given serializer.

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