Trait structural::field::multi_fields::RevGetMultiFieldMutImpl

pub unsafe trait RevGetMultiFieldMutImpl<'a, This: ?Sized + 'a>: IsMultiFieldPath<PathUniqueness = UniquePaths> + Sized {
    type UnnormFieldsMut: 'a + NormalizeFields;
    type UnnormFieldsRawMut: 'a + NormalizeFields;
    fn rev_get_multi_field_mut_impl(
        self, 
        this: &'a mut This
    ) -> Self::UnnormFieldsMut;
    unsafe fn rev_get_multi_field_raw_mut_impl(
        self, 
        this: *mut This
    ) -> Self::UnnormFieldsRawMut;
}

Gets mutable references to multiple fields from This, usually returning a tuple of Result<&mut _, E: IsFieldErr>s,

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

To get Option<&mut _>s and &mut _s instead of each of those Results, you can use the RevGetMultiFieldMut as a bound instead.

Safety

The rev_get_multi_field_raw_mut_impl method must return non-aliasing pointers, where all of them are safe to dereference.

As a reminder: mutable references imply uniqueness, which means that it's undefined behavior for implementors to return multiple mutable references to the same field from rev_get_multi_field_mut_impl.

Example

This example demonstrates how you can implement RevGetMultiFieldMutImpl to get a pair of indices.

use structural::field::{FailedAccess, RevGetMultiFieldMutImpl};
use structural::path::{IsMultiFieldPath, UniquePaths};
use structural::StructuralExt;

let mut arr=[2,3,5,8,13,21,34,55,89];

assert_eq!( arr[..].fields_mut(Pair::new(2,1)), (Some(&mut 5),Some(&mut 3)) );
assert_eq!( arr[..].fields_mut(Pair::new(0,3)), (Some(&mut 2),Some(&mut 8)) );

mod pair{
    pub struct Pair(usize,usize);
    impl Pair {
        pub fn first(&self)->usize{
            self.0
        }
        pub fn second(&self)->usize{
            self.1
        }
        pub fn new(first:usize, second:usize)->Self{
            assert_ne!(first,second,"Expected disjoint indices");
            Pair(first, second)
        }
    }
}
use pair::Pair;

impl IsMultiFieldPath for Pair{
    type PathUniqueness= UniquePaths;
}

unsafe impl<'a,T:'a> RevGetMultiFieldMutImpl<'a,[T]> for Pair{
    type UnnormFieldsMut=(
        Result<&'a mut T,FailedAccess>,
        Result<&'a mut T,FailedAccess>,
    );

    type UnnormFieldsRawMut=(
        Result<*mut T,FailedAccess>,
        Result<*mut T,FailedAccess>,
    );

    fn rev_get_multi_field_mut_impl(self, this: &'a mut [T]) -> Self::UnnormFieldsMut{
        // Pair ensures that the indices are disjoint in its constructor,
        // so there can't be overlapping mutable references.
        unsafe{
            let ret=self.rev_get_multi_field_raw_mut_impl(this);
            (
                ret.0.map(|x|&mut *x),
                ret.1.map(|x|&mut *x),
            )
        }
    }

    unsafe fn rev_get_multi_field_raw_mut_impl(
        self,
        this: *mut [T]
    ) -> Self::UnnormFieldsRawMut{
        (
            get_at_raw(this, self.first() ),
            get_at_raw(this, self.second()),
        )
    }
}

/// # Safety
///
/// The passed in `*mut [T]` must point to fully initialized memory.
///
/// The index that you pass in must not have already been borrowed.
unsafe fn get_at_raw<T>(this: *mut [T], index: usize)-> Result<*mut T, FailedAccess> {
    // There might be a better way to get the length of a `*mut [T]`.
    let len=(*this).len();

    if index < len {
        Ok(&mut *(this as *mut T).add(index) as *mut T)
    } else {
        Err(FailedAccess)
    }
}

Associated Types

type UnnormFieldsMut: 'a + NormalizeFields

This is usually a tuple of Result<&mut _,E: IsFieldErr>s.

type UnnormFieldsRawMut: 'a + NormalizeFields

This is usually a tuple of Result<*mut _,E: IsFieldErr>s.

Loading content...

Required methods

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

Gets mutable references to multiple fields from this, usually a tuple of Result<&mut _,E: IsFieldErr>s.

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

Gets raw pointers to multiple fields from this, usually a tuple of Result<*mut _,E: IsFieldErr>s.

Safety

this must point to a valid instance of This,which lives for the 'a lifetime.

Loading content...

Implementors

impl<'a, F, S, This: ?Sized, Mid: ?Sized, OutTy, OutRawTy, OutErr> RevGetMultiFieldMutImpl<'a, This> for NestedFieldPathSet<F, S, UniquePaths> where
    F: RevGetFieldMutImpl<'a, This, Ty = Mid, Err = OutErr>,
    FieldPathSet<S, UniquePaths>: RevGetMultiFieldMutImpl<'a, Mid, UnnormFieldsMut = OutTy, UnnormFieldsRawMut = OutRawTy>,
    This: 'a,
    OutErr: IsFieldErr,
    Mid: 'a,
    OutTy: 'a + NormalizeFields,
    OutRawTy: 'a + NormalizeFields,
    NestedFieldPathSetOutput<OutTy, OutErr>: 'a + NormalizeFields,
    NestedFieldPathSetOutput<OutRawTy, OutErr>: 'a + NormalizeFields, 

type UnnormFieldsMut = NestedFieldPathSetOutput<OutTy, OutErr>

type UnnormFieldsRawMut = NestedFieldPathSetOutput<OutRawTy, OutErr>

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> NestedFieldPathSetOutput<OutTy, OutErr>

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> NestedFieldPathSetOutput<OutRawTy, OutErr>

impl<'a, This: ?Sized + 'a> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(), UniquePaths>

type UnnormFieldsMut = ()

type UnnormFieldsRawMut = ()

fn rev_get_multi_field_mut_impl(self, _this: &'a mut This)

unsafe fn rev_get_multi_field_raw_mut_impl(self, _this: *mut This)

impl<'a, This: ?Sized + 'a> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<()>, UniquePaths>

type UnnormFieldsMut = ()

type UnnormFieldsRawMut = ()

fn rev_get_multi_field_mut_impl(self, _this: &'a mut This)

unsafe fn rev_get_multi_field_raw_mut_impl(self, _this: *mut This)

impl<'a, This: ?Sized, F0, E0, T0> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0,), UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>,)

type UnnormFieldsRawMut = (Result<*mut T0, E0>,)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0,)>, UniquePaths> where
    This: 'a,
    FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>,
    E0: 'a + NormalizeFields,
    T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>, 

type UnnormFieldsMut = E0

type UnnormFieldsRawMut = T0

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0,)>, UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>,)

type UnnormFieldsRawMut = (Result<*mut T0, E0>,)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1), UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1)>, UniquePaths> where
    This: 'a,
    FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>,
    E0: 'a + NormalizeFields,
    T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>,
    FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>,
    E1: 'a + NormalizeFields,
    T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>, 

type UnnormFieldsMut = (E0, E1)

type UnnormFieldsRawMut = (T0, T1)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1)>, UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2), UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2)>, UniquePaths> where
    This: 'a,
    FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>,
    E0: 'a + NormalizeFields,
    T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>,
    FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>,
    E1: 'a + NormalizeFields,
    T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>,
    FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>,
    E2: 'a + NormalizeFields,
    T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>, 

type UnnormFieldsMut = (E0, E1, E2)

type UnnormFieldsRawMut = (T0, T1, T2)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2)>, UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3), UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3)>, UniquePaths> where
    This: 'a,
    FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>,
    E0: 'a + NormalizeFields,
    T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>,
    FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>,
    E1: 'a + NormalizeFields,
    T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>,
    FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>,
    E2: 'a + NormalizeFields,
    T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>,
    FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>,
    E3: 'a + NormalizeFields,
    T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>, 

type UnnormFieldsMut = (E0, E1, E2, E3)

type UnnormFieldsRawMut = (T0, T1, T2, T3)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3)>, UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4), UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr,
    F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>,
    Result<&'a mut T4, E4>: NormalizeFields,
    Result<*mut T4, E4>: NormalizeFields,
    T4: 'a,
    E4: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4)>, UniquePaths> where
    This: 'a,
    FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>,
    E0: 'a + NormalizeFields,
    T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>,
    FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>,
    E1: 'a + NormalizeFields,
    T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>,
    FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>,
    E2: 'a + NormalizeFields,
    T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>,
    FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>,
    E3: 'a + NormalizeFields,
    T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>,
    FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E4, UnnormFieldsRawMut = T4>,
    E4: 'a + NormalizeFields,
    T4: 'a + NormalizeFields + DerefNested<'a, Dereffed = E4>, 

type UnnormFieldsMut = (E0, E1, E2, E3, E4)

type UnnormFieldsRawMut = (T0, T1, T2, T3, T4)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4)>, UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr,
    F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>,
    Result<&'a mut T4, E4>: NormalizeFields,
    Result<*mut T4, E4>: NormalizeFields,
    T4: 'a,
    E4: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5), UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr,
    F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>,
    Result<&'a mut T4, E4>: NormalizeFields,
    Result<*mut T4, E4>: NormalizeFields,
    T4: 'a,
    E4: IsFieldErr,
    F5: RevGetFieldMutImpl<'a, This, Ty = T5, Err = E5>,
    Result<&'a mut T5, E5>: NormalizeFields,
    Result<*mut T5, E5>: NormalizeFields,
    T5: 'a,
    E5: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>, Result<&'a mut T5, E5>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>, Result<*mut T5, E5>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5)>, UniquePaths> where
    This: 'a,
    FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>,
    E0: 'a + NormalizeFields,
    T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>,
    FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>,
    E1: 'a + NormalizeFields,
    T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>,
    FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>,
    E2: 'a + NormalizeFields,
    T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>,
    FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>,
    E3: 'a + NormalizeFields,
    T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>,
    FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E4, UnnormFieldsRawMut = T4>,
    E4: 'a + NormalizeFields,
    T4: 'a + NormalizeFields + DerefNested<'a, Dereffed = E4>,
    FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E5, UnnormFieldsRawMut = T5>,
    E5: 'a + NormalizeFields,
    T5: 'a + NormalizeFields + DerefNested<'a, Dereffed = E5>, 

type UnnormFieldsMut = (E0, E1, E2, E3, E4, E5)

type UnnormFieldsRawMut = (T0, T1, T2, T3, T4, T5)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5)>, UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr,
    F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>,
    Result<&'a mut T4, E4>: NormalizeFields,
    Result<*mut T4, E4>: NormalizeFields,
    T4: 'a,
    E4: IsFieldErr,
    F5: RevGetFieldMutImpl<'a, This, Ty = T5, Err = E5>,
    Result<&'a mut T5, E5>: NormalizeFields,
    Result<*mut T5, E5>: NormalizeFields,
    T5: 'a,
    E5: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>, Result<&'a mut T5, E5>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>, Result<*mut T5, E5>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr,
    F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>,
    Result<&'a mut T4, E4>: NormalizeFields,
    Result<*mut T4, E4>: NormalizeFields,
    T4: 'a,
    E4: IsFieldErr,
    F5: RevGetFieldMutImpl<'a, This, Ty = T5, Err = E5>,
    Result<&'a mut T5, E5>: NormalizeFields,
    Result<*mut T5, E5>: NormalizeFields,
    T5: 'a,
    E5: IsFieldErr,
    F6: RevGetFieldMutImpl<'a, This, Ty = T6, Err = E6>,
    Result<&'a mut T6, E6>: NormalizeFields,
    Result<*mut T6, E6>: NormalizeFields,
    T6: 'a,
    E6: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>, Result<&'a mut T5, E5>, Result<&'a mut T6, E6>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>, Result<*mut T5, E5>, Result<*mut T6, E6>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6)>, UniquePaths> where
    This: 'a,
    FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>,
    E0: 'a + NormalizeFields,
    T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>,
    FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>,
    E1: 'a + NormalizeFields,
    T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>,
    FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>,
    E2: 'a + NormalizeFields,
    T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>,
    FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>,
    E3: 'a + NormalizeFields,
    T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>,
    FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E4, UnnormFieldsRawMut = T4>,
    E4: 'a + NormalizeFields,
    T4: 'a + NormalizeFields + DerefNested<'a, Dereffed = E4>,
    FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E5, UnnormFieldsRawMut = T5>,
    E5: 'a + NormalizeFields,
    T5: 'a + NormalizeFields + DerefNested<'a, Dereffed = E5>,
    FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E6, UnnormFieldsRawMut = T6>,
    E6: 'a + NormalizeFields,
    T6: 'a + NormalizeFields + DerefNested<'a, Dereffed = E6>, 

type UnnormFieldsMut = (E0, E1, E2, E3, E4, E5, E6)

type UnnormFieldsRawMut = (T0, T1, T2, T3, T4, T5, T6)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6)>, UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr,
    F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>,
    Result<&'a mut T4, E4>: NormalizeFields,
    Result<*mut T4, E4>: NormalizeFields,
    T4: 'a,
    E4: IsFieldErr,
    F5: RevGetFieldMutImpl<'a, This, Ty = T5, Err = E5>,
    Result<&'a mut T5, E5>: NormalizeFields,
    Result<*mut T5, E5>: NormalizeFields,
    T5: 'a,
    E5: IsFieldErr,
    F6: RevGetFieldMutImpl<'a, This, Ty = T6, Err = E6>,
    Result<&'a mut T6, E6>: NormalizeFields,
    Result<*mut T6, E6>: NormalizeFields,
    T6: 'a,
    E6: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>, Result<&'a mut T5, E5>, Result<&'a mut T6, E6>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>, Result<*mut T5, E5>, Result<*mut T6, E6>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr,
    F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>,
    Result<&'a mut T4, E4>: NormalizeFields,
    Result<*mut T4, E4>: NormalizeFields,
    T4: 'a,
    E4: IsFieldErr,
    F5: RevGetFieldMutImpl<'a, This, Ty = T5, Err = E5>,
    Result<&'a mut T5, E5>: NormalizeFields,
    Result<*mut T5, E5>: NormalizeFields,
    T5: 'a,
    E5: IsFieldErr,
    F6: RevGetFieldMutImpl<'a, This, Ty = T6, Err = E6>,
    Result<&'a mut T6, E6>: NormalizeFields,
    Result<*mut T6, E6>: NormalizeFields,
    T6: 'a,
    E6: IsFieldErr,
    F7: RevGetFieldMutImpl<'a, This, Ty = T7, Err = E7>,
    Result<&'a mut T7, E7>: NormalizeFields,
    Result<*mut T7, E7>: NormalizeFields,
    T7: 'a,
    E7: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>, Result<&'a mut T5, E5>, Result<&'a mut T6, E6>, Result<&'a mut T7, E7>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>, Result<*mut T5, E5>, Result<*mut T6, E6>, Result<*mut T7, E7>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, UniquePaths> where
    This: 'a,
    FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E0, UnnormFieldsRawMut = T0>,
    E0: 'a + NormalizeFields,
    T0: 'a + NormalizeFields + DerefNested<'a, Dereffed = E0>,
    FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E1, UnnormFieldsRawMut = T1>,
    E1: 'a + NormalizeFields,
    T1: 'a + NormalizeFields + DerefNested<'a, Dereffed = E1>,
    FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E2, UnnormFieldsRawMut = T2>,
    E2: 'a + NormalizeFields,
    T2: 'a + NormalizeFields + DerefNested<'a, Dereffed = E2>,
    FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E3, UnnormFieldsRawMut = T3>,
    E3: 'a + NormalizeFields,
    T3: 'a + NormalizeFields + DerefNested<'a, Dereffed = E3>,
    FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E4, UnnormFieldsRawMut = T4>,
    E4: 'a + NormalizeFields,
    T4: 'a + NormalizeFields + DerefNested<'a, Dereffed = E4>,
    FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E5, UnnormFieldsRawMut = T5>,
    E5: 'a + NormalizeFields,
    T5: 'a + NormalizeFields + DerefNested<'a, Dereffed = E5>,
    FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E6, UnnormFieldsRawMut = T6>,
    E6: 'a + NormalizeFields,
    T6: 'a + NormalizeFields + DerefNested<'a, Dereffed = E6>,
    FieldPathSet<SmallPathSet<F7>, UniquePaths>: RevGetMultiFieldMutImpl<'a, This, UnnormFieldsMut = E7, UnnormFieldsRawMut = T7>,
    E7: 'a + NormalizeFields,
    T7: 'a + NormalizeFields + DerefNested<'a, Dereffed = E7>, 

type UnnormFieldsMut = (E0, E1, E2, E3, E4, E5, E6, E7)

type UnnormFieldsRawMut = (T0, T1, T2, T3, T4, T5, T6, T7)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, UniquePaths> where
    This: 'a,
    F0: RevGetFieldMutImpl<'a, This, Ty = T0, Err = E0>,
    Result<&'a mut T0, E0>: NormalizeFields,
    Result<*mut T0, E0>: NormalizeFields,
    T0: 'a,
    E0: IsFieldErr,
    F1: RevGetFieldMutImpl<'a, This, Ty = T1, Err = E1>,
    Result<&'a mut T1, E1>: NormalizeFields,
    Result<*mut T1, E1>: NormalizeFields,
    T1: 'a,
    E1: IsFieldErr,
    F2: RevGetFieldMutImpl<'a, This, Ty = T2, Err = E2>,
    Result<&'a mut T2, E2>: NormalizeFields,
    Result<*mut T2, E2>: NormalizeFields,
    T2: 'a,
    E2: IsFieldErr,
    F3: RevGetFieldMutImpl<'a, This, Ty = T3, Err = E3>,
    Result<&'a mut T3, E3>: NormalizeFields,
    Result<*mut T3, E3>: NormalizeFields,
    T3: 'a,
    E3: IsFieldErr,
    F4: RevGetFieldMutImpl<'a, This, Ty = T4, Err = E4>,
    Result<&'a mut T4, E4>: NormalizeFields,
    Result<*mut T4, E4>: NormalizeFields,
    T4: 'a,
    E4: IsFieldErr,
    F5: RevGetFieldMutImpl<'a, This, Ty = T5, Err = E5>,
    Result<&'a mut T5, E5>: NormalizeFields,
    Result<*mut T5, E5>: NormalizeFields,
    T5: 'a,
    E5: IsFieldErr,
    F6: RevGetFieldMutImpl<'a, This, Ty = T6, Err = E6>,
    Result<&'a mut T6, E6>: NormalizeFields,
    Result<*mut T6, E6>: NormalizeFields,
    T6: 'a,
    E6: IsFieldErr,
    F7: RevGetFieldMutImpl<'a, This, Ty = T7, Err = E7>,
    Result<&'a mut T7, E7>: NormalizeFields,
    Result<*mut T7, E7>: NormalizeFields,
    T7: 'a,
    E7: IsFieldErr, 

type UnnormFieldsMut = (Result<&'a mut T0, E0>, Result<&'a mut T1, E1>, Result<&'a mut T2, E2>, Result<&'a mut T3, E3>, Result<&'a mut T4, E4>, Result<&'a mut T5, E5>, Result<&'a mut T6, E6>, Result<&'a mut T7, E7>)

type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>, Result<*mut T5, E5>, Result<*mut T6, E6>, Result<*mut T7, E7>)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> Self::UnnormFieldsMut

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> Self::UnnormFieldsRawMut

impl<'a, This: ?Sized, T> RevGetMultiFieldMutImpl<'a, This> for NestedFieldPath<T> where
    Self: RevGetFieldMutImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields,
    Result<*mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, 

type UnnormFieldsMut = (Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>,)

type UnnormFieldsRawMut = (Result<*mut RGFT<Self, This>, RGFE<Self, This>>,)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> (Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>,)

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> (Result<*mut RGFT<Self, This>, RGFE<Self, This>>,)

impl<'a, This: ?Sized, T> RevGetMultiFieldMutImpl<'a, This> for TStr<T> where
    Self: RevGetFieldMutImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields,
    Result<*mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, 

type UnnormFieldsMut = (Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>,)

type UnnormFieldsRawMut = (Result<*mut RGFT<Self, This>, RGFE<Self, This>>,)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> (Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>,)

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> (Result<*mut RGFT<Self, This>, RGFE<Self, This>>,)

impl<'a, This: ?Sized, T> RevGetMultiFieldMutImpl<'a, This> for VariantName<T> where
    Self: RevGetFieldMutImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields,
    Result<*mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, 

type UnnormFieldsMut = (Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>,)

type UnnormFieldsRawMut = (Result<*mut RGFT<Self, This>, RGFE<Self, This>>,)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> (Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>,)

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> (Result<*mut RGFT<Self, This>, RGFE<Self, This>>,)

impl<'a, This: ?Sized, V, F> RevGetMultiFieldMutImpl<'a, This> for VariantField<V, F> where
    Self: RevGetFieldMutImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields,
    Result<*mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, 

type UnnormFieldsMut = (Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>,)

type UnnormFieldsRawMut = (Result<*mut RGFT<Self, This>, RGFE<Self, This>>,)

fn rev_get_multi_field_mut_impl(
    self,
    this: &'a mut This
) -> (Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>,)

unsafe fn rev_get_multi_field_raw_mut_impl(
    self,
    this: *mut This
) -> (Result<*mut RGFT<Self, This>, RGFE<Self, This>>,)

Loading content...