Struct partial_ref::Const

#[repr(transparent)]
pub struct Const<Part, Reference: HasTarget> { /* fields omitted */ }

A constant (immutable) part of a partial reference.

Trait Implementations

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

type Target = Reference::Target

The referenced type.

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

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

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

Create a partial reference from a raw pointer.

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

Access to the underlying raw pointer.

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

Partially re-borrows a partial reference.

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

Access a part of the referenced value.

fn part_mut<FieldPart, PartIndex, FieldType>(
    &'a mut self,
    _part: FieldPart
) -> &'a mut FieldType where
    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.

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

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

fn split_part<FieldPart, PartIndex, FieldType>(
    &'a mut self,
    _part: FieldPart
) -> (&'a FieldType, Self::Remainder) where
    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.

fn split_part_mut<FieldPart, PartIndex, FieldType>(
    &'a mut self,
    _part: FieldPart
) -> (&'a mut FieldType, Self::Remainder) where
    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.

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

(internal) Plucks the outermost constant part.

type Remainder = Const<PluckedPart, Reference>

The partial reference left after plucking.

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

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

type Remainder = Const<SkippedPart, Reference::Remainder>

The partial reference left after plucking.

impl<'a, ContainingPart, PluckedOuter, PluckedInner, Reference, NestedPartIndex, Index, OuterFieldType, ContainingFieldType> PluckConst<'a, Nested<PluckedOuter, PluckedInner>, IndexSplit<NestedPartIndex, Index>> for Const<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 constant first part.

type Remainder = Const<ContainingPart, Reference>

The partial reference left after plucking.

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

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

type Remainder = Const<SkippedPart, Reference::Remainder>

The partial reference left after plucking.

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

(internal) To have a reference with a constant first part as subset, pluck that part and make sure the remaining references are in a subset relation.

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

impl<SomePart, Reference: Copy + HasTarget> Copy for Const<SomePart, Reference>

A reference containing just constant parts is safe to clone.

impl<SomePart, Reference: Copy + HasTarget> Clone for Const<SomePart, Reference>

A reference containing just constant parts is safe to clone.

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.