Trait structural::field::rev_get_field::RevGetFieldMutImpl

pub unsafe trait RevGetFieldMutImpl<'a, This: ?Sized>: RevGetFieldImpl<'a, This> {
    fn rev_get_field_mut(
        self, 
        this: &'a mut This
    ) -> Result<&'a mut Self::Ty, Self::Err>;
    unsafe fn rev_get_field_raw_mut(
        self, 
        this: *mut This
    ) -> Result<*mut Self::Ty, Self::Err>;
}

Like Get*FieldMut,except that the parameters are reversed,

This is the type we are accessing,and Self is a field path.

This is used by the StructuralExt::field_mut method.

Safety

The rev_get_field_raw_mut function must return a valid pointer derived from the passed in pointer, that is safe to dereference mutably.

Locality of Implementations

You must only implement RevGetFieldMutImpl for field paths defined locally (in the same crate as the implementation itself).

This allows crate authors to add more RevGetFieldMutImpl impls while lowering the rist of aliasing the returned pointer from rev_get_field_raw_mut.

Use as bound

For examples of using RevGetFieldMutImpl as a bound look at example for:

• RevGetFieldMut: For infallible field access,generally struct fields,not inside of a nested enum.

• OptRevGetFieldMut: Fallible field access,generally for getting a field in a (potentially nested) enum.

Example

This example demonstrates implementing RevGetFieldMutImpl to choose between 2 fields based on a runtime value.

use structural::{
    field::{FailedAccess, RevFieldErr, RevFieldType, RevGetFieldImpl, RevGetFieldMutImpl},
    path::IsSingleFieldPath,
    StructuralExt, ts,
};

let mut tup=(3,5,8,13);

assert_eq!( tup.field_mut(Choose(Which::First, ts!(0), ts!(1))), &mut 3 );
assert_eq!( tup.field_mut(Choose(Which::Second, ts!(0), ts!(1))), &mut 5 );
assert_eq!( tup.field_mut(Choose(Which::First, ts!(1), ts!(2))), &mut 5 );
assert_eq!( tup.field_mut(Choose(Which::Second, ts!(1), ts!(2))), &mut 8 );


#[derive(Debug,Copy,Clone,PartialEq)]
struct Choose<P0,P1>(Which,P0,P1);

#[derive(Debug,Copy,Clone,PartialEq)]
enum Which{
    First,
    Second,
}

impl<P0,P1> IsSingleFieldPath for Choose<P0,P1>{}

impl<P0,P1,T> RevFieldType<T> for Choose<P0,P1>
where
    P0: RevFieldType<T>,
    P1: RevFieldType<T, Ty=P0::Ty>,
{
    type Ty = P0::Ty;
}

impl<P0,P1,T> RevFieldErr<T> for Choose<P0,P1>
where
    P0: RevFieldErr<T>,
    P1: RevFieldErr<T, Ty=P0::Ty, Err=P0::Err>,
{
    type Err = P0::Err;
}

impl<'a,P0,P1,T> RevGetFieldImpl<'a,T> for Choose<P0,P1>
where
    P0: RevGetFieldImpl<'a,T>,
    P1: RevGetFieldImpl<'a,T, Ty=P0::Ty, Err=P0::Err>,
{
    fn rev_get_field(self, this: &'a T) -> Result<&'a P0::Ty, P0::Err>{
        match self.0 {
            Which::First=>self.1.rev_get_field(this),
            Which::Second=>self.2.rev_get_field(this),
        }
    }
}

unsafe impl<'a,P0,P1,T> RevGetFieldMutImpl<'a,T> for Choose<P0,P1>
where
    P0: RevGetFieldMutImpl<'a,T>,
    P1: RevGetFieldMutImpl<'a,T, Ty=P0::Ty, Err=P0::Err>,
{
    fn rev_get_field_mut(self, this: &'a mut T) -> Result<&'a mut P0::Ty, P0::Err>{
        match self.0 {
            Which::First=>self.1.rev_get_field_mut(this),
            Which::Second=>self.2.rev_get_field_mut(this),
        }
    }

    unsafe fn rev_get_field_raw_mut(self, this: *mut  T) -> Result<*mut P0::Ty, P0::Err>{
        match self.0 {
            Which::First=>self.1.rev_get_field_raw_mut(this),
            Which::Second=>self.2.rev_get_field_raw_mut(this),
        }
    }
}

Required methods

fn rev_get_field_mut(
    self,
    this: &'a mut This
) -> Result<&'a mut Self::Ty, Self::Err>

Accesses the field that self represents inside of this,by mutable reference.

unsafe fn rev_get_field_raw_mut(
    self,
    this: *mut This
) -> Result<*mut Self::Ty, Self::Err>

Accesses the field that self represents inside of this,by raw pointer.

Safety

You must pass a pointer to a fully initialized instance of This.

Loading content...

Implementors

impl<'a, F0, T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, F6, T6, FL, TL, This: ?Sized, CombErr> RevGetFieldMutImpl<'a, This> for NestedFieldPath<(F0, F1, F2, F3, F4, F5, F6, FL)> where
    This: 'a,
    Self: RevGetFieldImpl<'a, This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0>,
    T0: 'a,
    F0::Err: IntoFieldErr<CombErr>,
    F1: RevGetFieldMutImpl<'a, T0, Ty = T1>,
    T1: 'a,
    F1::Err: IntoFieldErr<CombErr>,
    F2: RevGetFieldMutImpl<'a, T1, Ty = T2>,
    T2: 'a,
    F2::Err: IntoFieldErr<CombErr>,
    F3: RevGetFieldMutImpl<'a, T2, Ty = T3>,
    T3: 'a,
    F3::Err: IntoFieldErr<CombErr>,
    F4: RevGetFieldMutImpl<'a, T3, Ty = T4>,
    T4: 'a,
    F4::Err: IntoFieldErr<CombErr>,
    F5: RevGetFieldMutImpl<'a, T4, Ty = T5>,
    T5: 'a,
    F5::Err: IntoFieldErr<CombErr>,
    F6: RevGetFieldMutImpl<'a, T5, Ty = T6>,
    T6: 'a,
    F6::Err: IntoFieldErr<CombErr>,
    FL: RevGetFieldMutImpl<'a, T6, Ty = TL>,
    TL: 'a,
    FL::Err: IntoFieldErr<CombErr>,
    TL: Sized, 

fn rev_get_field_mut(self, field: &'a mut This) -> Result<&'a mut TL, CombErr>

unsafe fn rev_get_field_raw_mut(
    self,
    field: *mut This
) -> Result<*mut TL, CombErr>

impl<'a, F0, T0, F1, T1, F2, T2, F3, T3, F4, T4, F5, T5, FL, TL, This: ?Sized, CombErr> RevGetFieldMutImpl<'a, This> for NestedFieldPath<(F0, F1, F2, F3, F4, F5, FL)> where
    This: 'a,
    Self: RevGetFieldImpl<'a, This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0>,
    T0: 'a,
    F0::Err: IntoFieldErr<CombErr>,
    F1: RevGetFieldMutImpl<'a, T0, Ty = T1>,
    T1: 'a,
    F1::Err: IntoFieldErr<CombErr>,
    F2: RevGetFieldMutImpl<'a, T1, Ty = T2>,
    T2: 'a,
    F2::Err: IntoFieldErr<CombErr>,
    F3: RevGetFieldMutImpl<'a, T2, Ty = T3>,
    T3: 'a,
    F3::Err: IntoFieldErr<CombErr>,
    F4: RevGetFieldMutImpl<'a, T3, Ty = T4>,
    T4: 'a,
    F4::Err: IntoFieldErr<CombErr>,
    F5: RevGetFieldMutImpl<'a, T4, Ty = T5>,
    T5: 'a,
    F5::Err: IntoFieldErr<CombErr>,
    FL: RevGetFieldMutImpl<'a, T5, Ty = TL>,
    TL: 'a,
    FL::Err: IntoFieldErr<CombErr>,
    TL: Sized, 

fn rev_get_field_mut(self, field: &'a mut This) -> Result<&'a mut TL, CombErr>

unsafe fn rev_get_field_raw_mut(
    self,
    field: *mut This
) -> Result<*mut TL, CombErr>

impl<'a, F0, T0, F1, T1, F2, T2, F3, T3, F4, T4, FL, TL, This: ?Sized, CombErr> RevGetFieldMutImpl<'a, This> for NestedFieldPath<(F0, F1, F2, F3, F4, FL)> where
    This: 'a,
    Self: RevGetFieldImpl<'a, This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0>,
    T0: 'a,
    F0::Err: IntoFieldErr<CombErr>,
    F1: RevGetFieldMutImpl<'a, T0, Ty = T1>,
    T1: 'a,
    F1::Err: IntoFieldErr<CombErr>,
    F2: RevGetFieldMutImpl<'a, T1, Ty = T2>,
    T2: 'a,
    F2::Err: IntoFieldErr<CombErr>,
    F3: RevGetFieldMutImpl<'a, T2, Ty = T3>,
    T3: 'a,
    F3::Err: IntoFieldErr<CombErr>,
    F4: RevGetFieldMutImpl<'a, T3, Ty = T4>,
    T4: 'a,
    F4::Err: IntoFieldErr<CombErr>,
    FL: RevGetFieldMutImpl<'a, T4, Ty = TL>,
    TL: 'a,
    FL::Err: IntoFieldErr<CombErr>,
    TL: Sized, 

fn rev_get_field_mut(self, field: &'a mut This) -> Result<&'a mut TL, CombErr>

unsafe fn rev_get_field_raw_mut(
    self,
    field: *mut This
) -> Result<*mut TL, CombErr>

impl<'a, F0, T0, F1, T1, F2, T2, F3, T3, FL, TL, This: ?Sized, CombErr> RevGetFieldMutImpl<'a, This> for NestedFieldPath<(F0, F1, F2, F3, FL)> where
    This: 'a,
    Self: RevGetFieldImpl<'a, This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0>,
    T0: 'a,
    F0::Err: IntoFieldErr<CombErr>,
    F1: RevGetFieldMutImpl<'a, T0, Ty = T1>,
    T1: 'a,
    F1::Err: IntoFieldErr<CombErr>,
    F2: RevGetFieldMutImpl<'a, T1, Ty = T2>,
    T2: 'a,
    F2::Err: IntoFieldErr<CombErr>,
    F3: RevGetFieldMutImpl<'a, T2, Ty = T3>,
    T3: 'a,
    F3::Err: IntoFieldErr<CombErr>,
    FL: RevGetFieldMutImpl<'a, T3, Ty = TL>,
    TL: 'a,
    FL::Err: IntoFieldErr<CombErr>,
    TL: Sized, 

fn rev_get_field_mut(self, field: &'a mut This) -> Result<&'a mut TL, CombErr>

unsafe fn rev_get_field_raw_mut(
    self,
    field: *mut This
) -> Result<*mut TL, CombErr>

impl<'a, F0, T0, F1, T1, F2, T2, FL, TL, This: ?Sized, CombErr> RevGetFieldMutImpl<'a, This> for NestedFieldPath<(F0, F1, F2, FL)> where
    This: 'a,
    Self: RevGetFieldImpl<'a, This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0>,
    T0: 'a,
    F0::Err: IntoFieldErr<CombErr>,
    F1: RevGetFieldMutImpl<'a, T0, Ty = T1>,
    T1: 'a,
    F1::Err: IntoFieldErr<CombErr>,
    F2: RevGetFieldMutImpl<'a, T1, Ty = T2>,
    T2: 'a,
    F2::Err: IntoFieldErr<CombErr>,
    FL: RevGetFieldMutImpl<'a, T2, Ty = TL>,
    TL: 'a,
    FL::Err: IntoFieldErr<CombErr>,
    TL: Sized, 

fn rev_get_field_mut(self, field: &'a mut This) -> Result<&'a mut TL, CombErr>

unsafe fn rev_get_field_raw_mut(
    self,
    field: *mut This
) -> Result<*mut TL, CombErr>

impl<'a, F0, T0, F1, T1, FL, TL, This: ?Sized, CombErr> RevGetFieldMutImpl<'a, This> for NestedFieldPath<(F0, F1, FL)> where
    This: 'a,
    Self: RevGetFieldImpl<'a, This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0>,
    T0: 'a,
    F0::Err: IntoFieldErr<CombErr>,
    F1: RevGetFieldMutImpl<'a, T0, Ty = T1>,
    T1: 'a,
    F1::Err: IntoFieldErr<CombErr>,
    FL: RevGetFieldMutImpl<'a, T1, Ty = TL>,
    TL: 'a,
    FL::Err: IntoFieldErr<CombErr>,
    TL: Sized, 

fn rev_get_field_mut(self, field: &'a mut This) -> Result<&'a mut TL, CombErr>

unsafe fn rev_get_field_raw_mut(
    self,
    field: *mut This
) -> Result<*mut TL, CombErr>

impl<'a, F0, T0, FL, TL, This: ?Sized, CombErr> RevGetFieldMutImpl<'a, This> for NestedFieldPath<(F0, FL)> where
    This: 'a,
    Self: RevGetFieldImpl<'a, This, Ty = TL, Err = CombErr>,
    CombErr: IsFieldErr,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0>,
    T0: 'a,
    F0::Err: IntoFieldErr<CombErr>,
    FL: RevGetFieldMutImpl<'a, T0, Ty = TL>,
    TL: 'a,
    FL::Err: IntoFieldErr<CombErr>,
    TL: Sized, 

fn rev_get_field_mut(self, field: &'a mut This) -> Result<&'a mut TL, CombErr>

unsafe fn rev_get_field_raw_mut(
    self,
    field: *mut This
) -> Result<*mut TL, CombErr>

impl<'a, This: ?Sized> RevGetFieldMutImpl<'a, This> for NestedFieldPath<()> where
    This: 'a, 

fn rev_get_field_mut(
    self,
    this: &'a mut This
) -> Result<&'a mut Self::Ty, Self::Err>

unsafe fn rev_get_field_raw_mut(
    self,
    this: *mut This
) -> Result<*mut Self::Ty, Self::Err>

impl<'a, This: ?Sized, A, B, U> RevGetFieldMutImpl<'a, This> for NestedFieldPathSet<A, (B,), U> where
    This: 'a,
    A: RevGetFieldMutImpl<'a, This>,
    B: RevGetFieldMutImpl<'a, A::Ty>,
    A::Ty: 'a,
    Self: RevFieldErr<This, Ty = B::Ty>,
    A::Err: IntoFieldErr<Self::Err>,
    B::Err: IntoFieldErr<Self::Err>, 

fn rev_get_field_mut(
    self,
    this: &'a mut This
) -> Result<&'a mut B::Ty, Self::Err>

unsafe fn rev_get_field_raw_mut(
    self,
    this: *mut This
) -> Result<*mut B::Ty, Self::Err>

impl<'a, This: ?Sized, F0> RevGetFieldMutImpl<'a, This> for NestedFieldPath<(F0,)> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This>, 

fn rev_get_field_mut(
    self,
    this: &'a mut This
) -> Result<&'a mut F0::Ty, F0::Err>

unsafe fn rev_get_field_raw_mut(
    self,
    this: *mut This
) -> Result<*mut F0::Ty, F0::Err>

impl<'a, This: ?Sized, S> RevGetFieldMutImpl<'a, This> for VariantName<TStr<S>> where
    This: 'a + IsVariant<TStr<S>>,
    S: 'static, 

fn rev_get_field_mut(
    self,
    this: &'a mut This
) -> Result<&'a mut VariantProxy<This, TStr<S>>, FailedAccess>

unsafe fn rev_get_field_raw_mut(
    self,
    this: *mut This
) -> Result<*mut VariantProxy<This, TStr<S>>, FailedAccess>

impl<'a, This: ?Sized, T> RevGetFieldMutImpl<'a, This> for TStr<T> where
    This: 'a + GetFieldMut<Self>,
    This::Ty: 'a, 

fn rev_get_field_mut(
    self,
    this: &'a mut This
) -> Result<&'a mut This::Ty, InfallibleAccess>

unsafe fn rev_get_field_raw_mut(
    self,
    this: *mut This
) -> Result<*mut This::Ty, InfallibleAccess>

impl<'a, This: ?Sized, T, U> RevGetFieldMutImpl<'a, This> for FieldPathSet<(T,), U> where
    This: 'a,
    T: RevGetFieldMutImpl<'a, This>, 

fn rev_get_field_mut(self, this: &'a mut This) -> Result<&'a mut T::Ty, T::Err>

unsafe fn rev_get_field_raw_mut(
    self,
    this: *mut This
) -> Result<*mut T::Ty, T::Err>

impl<'a, This: ?Sized, _V, _F> RevGetFieldMutImpl<'a, This> for VariantField<_V, _F> where
    This: 'a + GetVariantFieldMut<_V, _F>,
    This::Ty: 'a, 

fn rev_get_field_mut(
    self,
    this: &'a mut This
) -> Result<&'a mut This::Ty, FailedAccess>

unsafe fn rev_get_field_raw_mut(
    self,
    this: *mut This
) -> Result<*mut This::Ty, FailedAccess>

Loading content...