Struct CopyValueMut

pub struct CopyValueMut<'a, V = ()>
where
    V: ?Sized,
{ /* private fields */ }

A generic mutable Copy value reference.

Implementations

impl<'a, V> CopyValueMut<'a, V>

pub fn new<T: CopyElem>(typed: &'a mut T) -> CopyValueMut<'a, V>

where V: VTable<T>,

Create a new CopyValueMut from a typed mutable reference.

impl<'a, V: ?Sized> CopyValueMut<'a, V>

pub fn size(&self) -> usize

Get the size of the value pointed-to by this reference.

pub fn value_type_id(&self) -> TypeId

Get the TypeId of the referenced value.

pub fn value_alignment(&self) -> usize

Get the alignment of the referenced value.

pub fn is<T: 'static>(&self) -> bool

Returns true if this referenced value’s type is the same as T.

pub fn copy(self, other: CopyValueRef<'a, V>) -> Option<Self>

Copy value from other to self and return Self.

This function returns None if the values have different types.

pub fn swap(&mut self, other: &mut CopyValueMut<'_, V>)

Swap the values between other and self.

pub fn downcast<T: CopyElem>(self) -> Option<&'a mut T>

Downcast this value reference into a borrowed T type. Return None if the downcast fails.

pub fn upcast<U: From<V>>(&mut self) -> CopyValueMut<'_, U>

where V: Clone,

Trait Implementations

impl<'a, V: ?Sized + HasDebug> Debug for CopyValueMut<'a, V>

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

Formats the value using the given formatter.

impl<'a, V> From<CopyValueMut<'a, V>> for CopyValueRef<'a, V>

fn from(v: CopyValueMut<'a, V>) -> CopyValueRef<'a, V>

Converts to this type from the input type.

impl<'a, V: Any + Clone> From<CopyValueMut<'a, V>> for ValueMut<'a, (DropFn, V)>

fn from(v: CopyValueMut<'a, V>) -> ValueMut<'a, (DropFn, V)>

Converts to this type from the input type.

impl<'a, V: ?Sized + HasHash> Hash for CopyValueMut<'a, V>

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<'a, V: ?Sized + HasPartialEq> PartialEq for CopyValueMut<'a, V>

fn eq(&self, other: &Self) -> 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, V: ?Sized + HasEq> Eq for CopyValueMut<'a, V>

impl<'a, V: ?Sized + HasSend> Send for CopyValueMut<'a, V>

impl<'a, V: ?Sized + HasSync> Sync for CopyValueMut<'a, V>