Struct partial_ref::Mut

#[repr(transparent)]
pub struct Mut<Part, Reference> { /* private fields */ }

Expand description

A mutable part of a partial reference.

Trait Implementations

impl<'a, SomePart: Part, Reference: PartialRef<'a>> PartialRef<'a> for Mut<SomePart, Reference>where
Reference::Target: HasPart<SomePart>,

Extending a valid reference by a mutable part is still a valid reference when the reference target has such a part.

type Target = <Reference as PartialRef<'a>>::Target

The referenced type. Read more

unsafe fn from_raw(
ptr: *mut <Self::Target as PartialRefTarget>::RawTarget
) -> Self

Create a partial reference from a raw pointer. Read more

fn get_raw(&self) -> *mut <Self::Target as PartialRefTarget>::RawTarget

Access to the underlying raw pointer. Read more

fn borrow<'b, BorrowedRef, SubsetIndex>(&'b mut self) -> BorrowedRefwhere
    'a: 'b,
    BorrowedRef: PartialRef<'a, Target = Self::Target>,
    Self: HasSubset<'a, BorrowedRef, SubsetIndex>,

Partially re-borrows a partial reference. Read more

fn part<'b, FieldPart, PartIndex, FieldType>(
    &'b mut self,
    _part: FieldPart
) -> &'a FieldTypewhere
    'a: 'b,
    FieldType: ?Sized,
    FieldPart: Part<PartType = Field<FieldType>>,
    Self: PluckConst<'a, FieldPart, PartIndex>,
    Self::Target: HasPart<FieldPart> + 'a,

Access a part of the referenced value. Read more

fn part_mut<'b, FieldPart, PartIndex, FieldType>(
    &'b mut self,
    _part: FieldPart
) -> &'a mut FieldTypewhere
    'a: 'b,
    FieldType: ?Sized,
    FieldPart: Part<PartType = Field<FieldType>>,
    Self: PluckMut<'a, FieldPart, PartIndex>,
    Self::Target: HasPart<FieldPart> + 'a,

Mutable access to a part of the referenced value. Read more

fn split_borrow<'b, BorrowedRef, SubsetIndex>(
    &'b mut self
) -> (BorrowedRef, Self::Remainder)where
    'a: 'b,
    BorrowedRef: PartialRef<'a, Target = Self::Target>,
    Self: HasSubset<'a, BorrowedRef, SubsetIndex>,

Partially re-borrows a partial reference, splitting off the remaining parts. Read more

fn split_part<'b, FieldPart, PartIndex, FieldType>(
    &'b mut self,
    _part: FieldPart
) -> (&'a FieldType, Self::Remainder)where
    'a: 'b,
    FieldType: ?Sized,
    FieldPart: Part<PartType = Field<FieldType>>,
    Self: PluckConst<'a, FieldPart, PartIndex>,
    Self::Target: HasPart<FieldPart> + 'a,

Access a part of the referenced value, splitting off the remaining parts. Read more

fn split_part_mut<'b, FieldPart, PartIndex, FieldType>(
    &'b mut self,
    _part: FieldPart
) -> (&'a mut FieldType, Self::Remainder)where
    'a: 'b,
    FieldType: ?Sized,
    FieldPart: Part<PartType = Field<FieldType>>,
    Self: PluckMut<'a, FieldPart, PartIndex>,
    Self::Target: HasPart<FieldPart> + 'a,

Mutable access to a part of the referenced value, splitting off the remaining parts. Read more

impl<'a, ContainingPart, PluckedOuter, PluckedInner, Reference, NestedPartIndex, Index, OuterFieldType, ContainingFieldType> PluckConst<'a, Nested<PluckedOuter, PluckedInner>, IndexSplit<NestedPartIndex, Index>> for Mut<ContainingPart, Reference>where
    PluckedOuter: Part<PartType = Field<OuterFieldType>>,
    PluckedInner: Part,
    ContainingPart: Part<PartType = Field<ContainingFieldType>>,
    ContainingFieldType: SplitIntoParts<'a, ContainingPart, Reference>,
    ContainingFieldType: ?Sized,
    ContainingFieldType::ResultMut: PluckConst<'a, Nested<PluckedOuter, PluckedInner>, Index>,
    OuterFieldType: ?Sized,
    OuterFieldType: HasPart<PluckedInner>,
    OuterFieldType: PartialRefTarget<RawTarget = OuterFieldType>,
    Reference: PartialRef<'a>,
    Reference::Target: HasPart<ContainingPart>,
    ContainingPart: ContainsNestedPart<PluckedOuter, NestedPartIndex>,

(internal) Pluck a constant nested subpart of the mutable first part.

This leaves all other subparts as mutable in the remaining reference.

type Remainder = <<ContainingFieldType as SplitIntoParts<'a, ContainingPart, Reference>>::ResultMut as PluckConst<'a, Nested<PluckedOuter, PluckedInner>, Index>>::Remainder

The partial reference left after plucking.

impl<'a, PluckedPart, Reference> PluckConst<'a, PluckedPart, IndexHere> for Mut<PluckedPart, Reference>where
    PluckedPart: Part,
    Reference: PartialRef<'a>,
    Reference::Target: HasPart<PluckedPart>,

(internal) Plucks the first part, converting it from mutable to constant.

type Remainder = Const<PluckedPart, Reference>

The partial reference left after plucking.

impl<'a, PluckedPart, SkippedPart, Reference, Index> PluckConst<'a, PluckedPart, IndexNext<Index>> for Mut<SkippedPart, Reference>where
    PluckedPart: Part,
    SkippedPart: Part,
    Reference::Target: HasPart<PluckedPart>,
    Reference::Target: HasPart<SkippedPart>,
    Reference: PluckConst<'a, PluckedPart, Index>,

(internal) Skips the mutable first part while plucking a constant part.

type Remainder = Mut<SkippedPart, <Reference as PluckConst<'a, PluckedPart, Index>>::Remainder>

The partial reference left after plucking.

impl<'a, ContainingPart, PluckedOuter, PluckedInner, Reference, NestedPartIndex, Index, OuterFieldType, ContainingFieldType> PluckMut<'a, Nested<PluckedOuter, PluckedInner>, IndexSplit<NestedPartIndex, Index>> for Mut<ContainingPart, Reference>where
    PluckedOuter: Part<PartType = Field<OuterFieldType>>,
    PluckedInner: Part,
    ContainingPart: Part<PartType = Field<ContainingFieldType>>,
    ContainingFieldType: SplitIntoParts<'a, ContainingPart, Reference>,
    ContainingFieldType: ?Sized,
    ContainingFieldType::ResultMut: PluckMut<'a, Nested<PluckedOuter, PluckedInner>, Index>,
    OuterFieldType: ?Sized,
    OuterFieldType: HasPart<PluckedInner>,
    OuterFieldType: PartialRefTarget<RawTarget = OuterFieldType>,
    Reference: PartialRef<'a>,
    Reference::Target: HasPart<ContainingPart>,
    ContainingPart: ContainsNestedPart<PluckedOuter, NestedPartIndex>,

(internal) Pluck a mutable nested subpart of the mutable first part.

This leaves all other subparts in the remaining reference.

type Remainder = <<ContainingFieldType as SplitIntoParts<'a, ContainingPart, Reference>>::ResultMut as PluckMut<'a, Nested<PluckedOuter, PluckedInner>, Index>>::Remainder

The partial reference left after plucking.

impl<'a, PluckedPart, Reference> PluckMut<'a, PluckedPart, IndexHere> for Mut<PluckedPart, Reference>where
    PluckedPart: Part,
    Reference: PartialRef<'a>,
    Reference::Target: HasPart<PluckedPart>,

(internal) Plucks the first mutable part.

type Remainder = Reference

The partial reference left after plucking.

impl<'a, PluckedPart, SkippedPart, Reference, Index> PluckMut<'a, PluckedPart, IndexNext<Index>> for Mut<SkippedPart, Reference>where
    PluckedPart: Part,
    SkippedPart: Part,
    Reference::Target: HasPart<PluckedPart>,
    Reference::Target: HasPart<SkippedPart>,
    Reference: PluckMut<'a, PluckedPart, Index>,

(internal) Skips the mutable first part while plucking a mutable part.

type Remainder = Mut<SkippedPart, <Reference as PluckMut<'a, PluckedPart, Index>>::Remainder>

The partial reference left after plucking.

Auto Trait Implementations

impl<Part, Reference> RefUnwindSafe for Mut<Part, Reference>where
Part: RefUnwindSafe,
Reference: RefUnwindSafe,

impl<Part, Reference> Send for Mut<Part, Reference>where
Part: Send,
Reference: Send,

impl<Part, Reference> Sync for Mut<Part, Reference>where
Part: Sync,
Reference: Sync,

impl<Part, Reference> Unpin for Mut<Part, Reference>where
Part: Unpin,
Reference: Unpin,

impl<Part, Reference> UnwindSafe for Mut<Part, Reference>where
Part: UnwindSafe,
Reference: UnwindSafe,

Blanket Implementations

impl<T> Any for Twhere
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for Twhere
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

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

const: unstable · source

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

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

impl<Reference, Outer, OuterFieldType, Inner> HasPart<Nested<Outer, Inner>> for Referencewhere
    Reference: HasPart<Outer> + ?Sized,
    Outer: Part<PartType = Field<OuterFieldType>>,
    Inner: Part,
    OuterFieldType: HasPart<Inner, RawTarget = OuterFieldType> + PartialRefTarget + ?Sized,

unsafe fn part_ptr(
ptr: *const <Reference as PartialRefTarget>::RawTarget
) -> <<Inner as Part>::PartType as PartType>::Ptr

Given a constant pointer to a target, produce a constant pointer to a part of it.

unsafe fn part_ptr_mut(
ptr: *mut <Reference as PartialRefTarget>::RawTarget
) -> <<Inner as Part>::PartType as PartType>::PtrMut

Given a mutable pointer to a target, produce a mutable pointer to a part of it.

impl<'a, SubsetPart, Reference, PluckedRef, PartIndex, TailIndex> HasSubset<'a, Const<SubsetPart, Reference>, SubsetIndexCons<PartIndex, TailIndex>> for PluckedRefwhere
PluckedRef: PluckConst<'a, SubsetPart, PartIndex>,
<PluckedRef as PluckConst<'a, SubsetPart, PartIndex>>::Remainder: HasSubset<'a, Reference, TailIndex>,

type Remainder = <<PluckedRef as PluckConst<'a, SubsetPart, PartIndex>>::Remainder as HasSubset<'a, Reference, TailIndex>>::Remainder

impl<'a, SubsetPart, Reference, PluckedRef, PartIndex, TailIndex> HasSubset<'a, Mut<SubsetPart, Reference>, SubsetIndexCons<PartIndex, TailIndex>> for PluckedRefwhere
PluckedRef: PluckMut<'a, SubsetPart, PartIndex>,
<PluckedRef as PluckMut<'a, SubsetPart, PartIndex>>::Remainder: HasSubset<'a, Reference, TailIndex>,

type Remainder = <<PluckedRef as PluckMut<'a, SubsetPart, PartIndex>>::Remainder as HasSubset<'a, Reference, TailIndex>>::Remainder

impl<'a, Reference> HasSubset<'a, Ref<'a, <Reference as PartialRef<'a>>::Target>, SubsetIndexEnd> for Referencewhere
Reference: PartialRef<'a>,

type Remainder = Reference

impl<T, U> Into<U> for Twhere
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T, U> TryFrom<U> for Twhere
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for Twhere
U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.