Trait structural::field::GetFieldMut

pub unsafe trait GetFieldMut<FieldName>: GetField<FieldName> {
    fn get_field_mut_(&mut self, field_name: FieldName) -> &mut Self::Ty;
    unsafe fn get_field_raw_mut(
        ptr: *mut (), 
        field_name: FieldName
    ) -> *mut Self::Ty
    where
        Self: Sized;
    fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<FieldName, Self::Ty>;
}

Allows accessing the FieldName field mutably.

Safety

These are requirements for manual implementations.

Implementors ought not mutate fields inside their accessor trait impls, or the accessor trait impls of other fields.

It is recommended that you use the z_unsafe_impl_get_field_raw_mut macro if you only borrow a field of the type.

Implementing get_field_raw_mut

Your implementation of GetFieldMut::get_field_raw_mut must ensure these properties:

• It must be side-effect free,

• The method must return a pointer to a fully initialized field,

• The field you access must always be the same one.

• That no implementation returns a pointer to a field that (other) implementations for the same type also return,

• That no implementation returns a pointer to a field that (other) GetVariantFieldMut implementations for the same type also return,

You can unerase the pointer by casting it to *mut Self (you can also use any type that's compatible with Self).

Your implementation of the get_field_raw_mut_fn method must only return a function pointer to a function that ensures the properties listed above.

Example: Usage as Bound

use structural::{StructuralExt,GetFieldMut,FP,fp};
use structural::for_examples::{Struct2,Struct3};

fn example<T>(this:&mut T)
where
    T: GetFieldMut<FP!(foo), Ty=Option<u32>> + GetFieldMut<FP!(bar), Ty=&'static str>
{
    assert_eq!( this.field_(fp!(foo)), &Some(21) );
    assert_eq!( this.field_(fp!(bar)), &"oh boy" );
    assert_eq!( this.fields(fp!(foo,bar)), (&Some(21), &"oh boy") );
    assert_eq!( this.cloned_fields(fp!(foo,bar)), (Some(21), "oh boy") );

    assert_eq!( this.field_mut(fp!(foo)), &mut Some(21) );
    assert_eq!( this.field_mut(fp!(bar)), &mut "oh boy" );
    assert_eq!( this.fields_mut(fp!(foo,bar)), (&mut Some(21), &mut "oh boy") );
}

example(&mut Struct2{ foo:Some(21), bar: "oh boy" });
example(&mut Struct3{ foo:Some(21), bar: "oh boy", baz:5 });

Example: Manual implementation

While this trait is intended to be implemented using the Structural derive macro, you can also implement it like this:

use structural::{FieldType,GetField,GetFieldMut,Structural,FP};

struct Huh<T>{
    value:T,
}

impl<T> Structural for Huh<T>{}

impl<T> FieldType<FP!(value)> for Huh<T>{
    type Ty=T;
}

impl<T> GetField<FP!(value)> for Huh<T>{
    fn get_field_(&self,_:FP!(value))->&Self::Ty{
        &self.value
    }
}

unsafe impl<T> GetFieldMut<FP!(value)> for Huh<T>{
    fn get_field_mut_(&mut self,_:FP!(value))->&mut Self::Ty{
        &mut self.value
    }
    structural::z_unsafe_impl_get_field_raw_mut!{
        Self,
        field_tstr=value,
        name_generic=FP!(value),
    }
}

Required methods

fn get_field_mut_(&mut self, field_name: FieldName) -> &mut Self::Ty

Accesses the FieldName field by mutable reference.

unsafe fn get_field_raw_mut(
    ptr: *mut (),
    field_name: FieldName
) -> *mut Self::Ty where
    Self: Sized, 

Gets a mutable pointer for the field.

Safety

You must pass a pointer casted from *mut Self to *mut (), pointing to a fully initialized instance of the type.

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<FieldName, Self::Ty>

Gets the get_field_raw_mut associated function as a function pointer.

Loading content...

Implementations on Foreign Types

impl<T, P> GetFieldMut<P> for [T; 0] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 1] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 2] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 3] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 4] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 5] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 6] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 7] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 8] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 9] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 10] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 11] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 12] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 13] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 14] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 15] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 16] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 17] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 18] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 19] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 20] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 21] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 22] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 23] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 24] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 25] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 26] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 27] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 28] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 29] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 30] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 31] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T, P> GetFieldMut<P> for [T; 32] where
    P: IsPathForArray<Self>, 

fn get_field_mut_(&mut self, _: P) -> &mut Self::Ty

unsafe fn get_field_raw_mut(ptr: *mut (), _: P) -> *mut Self::Ty

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<P, Self::Ty>

impl<T> GetFieldMut<TStr<__TS<(__s, __t, __a, __r, __t)>>> for Range<T>

fn get_field_mut_(
    &mut self,
    _: TStr<__TS<(__s, __t, __a, __r, __t)>>
) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__s, __t, __a, __r, __t)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__s, __t, __a, __r, __t)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__s, __t, __a, __r, __t)>>, GetFieldType<Self, TStr<__TS<(__s, __t, __a, __r, __t)>>>>

impl<T> GetFieldMut<TStr<__TS<(__e, __n, __d)>>> for Range<T>

fn get_field_mut_(&mut self, _: TStr<__TS<(__e, __n, __d)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__e, __n, __d)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__e, __n, __d)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__e, __n, __d)>>, GetFieldType<Self, TStr<__TS<(__e, __n, __d)>>>>

impl<T> GetFieldMut<TStr<__TS<(__s, __t, __a, __r, __t)>>> for RangeFrom<T>

fn get_field_mut_(
    &mut self,
    _: TStr<__TS<(__s, __t, __a, __r, __t)>>
) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__s, __t, __a, __r, __t)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__s, __t, __a, __r, __t)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__s, __t, __a, __r, __t)>>, GetFieldType<Self, TStr<__TS<(__s, __t, __a, __r, __t)>>>>

impl<T> GetFieldMut<TStr<__TS<(__e, __n, __d)>>> for RangeTo<T>

fn get_field_mut_(&mut self, _: TStr<__TS<(__e, __n, __d)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__e, __n, __d)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__e, __n, __d)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__e, __n, __d)>>, GetFieldType<Self, TStr<__TS<(__e, __n, __d)>>>>

impl<T> GetFieldMut<TStr<__TS<(__e, __n, __d)>>> for RangeToInclusive<T>

fn get_field_mut_(&mut self, _: TStr<__TS<(__e, __n, __d)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__e, __n, __d)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__e, __n, __d)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__e, __n, __d)>>, GetFieldType<Self, TStr<__TS<(__e, __n, __d)>>>>

impl<T, __F, __Ty> GetFieldMut<__F> for ManuallyDrop<T> where
    ManuallyDrop<T>: Sized,
    T: GetFieldMut<__F, Ty = __Ty>, 

fn get_field_mut_(&mut self, fname: __F) -> &mut __Ty

unsafe fn get_field_raw_mut(this: *mut (), fname: __F) -> *mut __Ty where
    Self: Sized, 

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

impl<T, __F, __Ty> GetFieldMut<__F> for Box<T> where
    Box<T>: Sized,
    T: GetFieldMut<__F, Ty = __Ty>,
    T: ?Sized, 

fn get_field_mut_(&mut self, fname: __F) -> &mut __Ty

unsafe fn get_field_raw_mut(this: *mut (), fname: __F) -> *mut __Ty where
    Self: Sized, 

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

impl<'a, T, __F, __Ty> GetFieldMut<__F> for &'a mut T where
    &'a mut T: Sized,
    T: GetFieldMut<__F, Ty = __Ty>,
    T: 'a + ?Sized, 

fn get_field_mut_(&mut self, fname: __F) -> &mut __Ty

unsafe fn get_field_raw_mut(this: *mut (), fname: __F) -> *mut __Ty where
    Self: Sized, 

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

impl<C0> GetFieldMut<TStr<__TS<(__0,)>>> for (C0,)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2, C3)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2, C3> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2, C3)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2, C3> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2, C3)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3> GetFieldMut<TStr<__TS<(__3,)>>> for (C0, C1, C2, C3)

fn get_field_mut_(&mut self, _: TStr<__TS<(__3,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__3,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__3,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__3,)>>, GetFieldType<Self, TStr<__TS<(__3,)>>>>

impl<C0, C1, C2, C3, C4> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2, C3, C4)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2, C3, C4> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2, C3, C4)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2, C3, C4> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2, C3, C4)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3, C4> GetFieldMut<TStr<__TS<(__3,)>>> for (C0, C1, C2, C3, C4)

fn get_field_mut_(&mut self, _: TStr<__TS<(__3,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__3,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__3,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__3,)>>, GetFieldType<Self, TStr<__TS<(__3,)>>>>

impl<C0, C1, C2, C3, C4> GetFieldMut<TStr<__TS<(__4,)>>> for (C0, C1, C2, C3, C4)

fn get_field_mut_(&mut self, _: TStr<__TS<(__4,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__4,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__4,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__4,)>>, GetFieldType<Self, TStr<__TS<(__4,)>>>>

impl<C0, C1, C2, C3, C4, C5> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2, C3, C4, C5)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2, C3, C4, C5> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2, C3, C4, C5)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2, C3, C4, C5> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2, C3, C4, C5)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3, C4, C5> GetFieldMut<TStr<__TS<(__3,)>>> for (C0, C1, C2, C3, C4, C5)

fn get_field_mut_(&mut self, _: TStr<__TS<(__3,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__3,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__3,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__3,)>>, GetFieldType<Self, TStr<__TS<(__3,)>>>>

impl<C0, C1, C2, C3, C4, C5> GetFieldMut<TStr<__TS<(__4,)>>> for (C0, C1, C2, C3, C4, C5)

fn get_field_mut_(&mut self, _: TStr<__TS<(__4,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__4,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__4,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__4,)>>, GetFieldType<Self, TStr<__TS<(__4,)>>>>

impl<C0, C1, C2, C3, C4, C5> GetFieldMut<TStr<__TS<(__5,)>>> for (C0, C1, C2, C3, C4, C5)

fn get_field_mut_(&mut self, _: TStr<__TS<(__5,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__5,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__5,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__5,)>>, GetFieldType<Self, TStr<__TS<(__5,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2, C3, C4, C5, C6)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2, C3, C4, C5, C6)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2, C3, C4, C5, C6)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6> GetFieldMut<TStr<__TS<(__3,)>>> for (C0, C1, C2, C3, C4, C5, C6)

fn get_field_mut_(&mut self, _: TStr<__TS<(__3,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__3,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__3,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__3,)>>, GetFieldType<Self, TStr<__TS<(__3,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6> GetFieldMut<TStr<__TS<(__4,)>>> for (C0, C1, C2, C3, C4, C5, C6)

fn get_field_mut_(&mut self, _: TStr<__TS<(__4,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__4,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__4,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__4,)>>, GetFieldType<Self, TStr<__TS<(__4,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6> GetFieldMut<TStr<__TS<(__5,)>>> for (C0, C1, C2, C3, C4, C5, C6)

fn get_field_mut_(&mut self, _: TStr<__TS<(__5,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__5,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__5,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__5,)>>, GetFieldType<Self, TStr<__TS<(__5,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6> GetFieldMut<TStr<__TS<(__6,)>>> for (C0, C1, C2, C3, C4, C5, C6)

fn get_field_mut_(&mut self, _: TStr<__TS<(__6,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__6,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__6,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__6,)>>, GetFieldType<Self, TStr<__TS<(__6,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7> GetFieldMut<TStr<__TS<(__3,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7)

fn get_field_mut_(&mut self, _: TStr<__TS<(__3,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__3,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__3,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__3,)>>, GetFieldType<Self, TStr<__TS<(__3,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7> GetFieldMut<TStr<__TS<(__4,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7)

fn get_field_mut_(&mut self, _: TStr<__TS<(__4,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__4,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__4,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__4,)>>, GetFieldType<Self, TStr<__TS<(__4,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7> GetFieldMut<TStr<__TS<(__5,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7)

fn get_field_mut_(&mut self, _: TStr<__TS<(__5,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__5,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__5,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__5,)>>, GetFieldType<Self, TStr<__TS<(__5,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7> GetFieldMut<TStr<__TS<(__6,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7)

fn get_field_mut_(&mut self, _: TStr<__TS<(__6,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__6,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__6,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__6,)>>, GetFieldType<Self, TStr<__TS<(__6,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7> GetFieldMut<TStr<__TS<(__7,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7)

fn get_field_mut_(&mut self, _: TStr<__TS<(__7,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__7,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__7,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__7,)>>, GetFieldType<Self, TStr<__TS<(__7,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8> GetFieldMut<TStr<__TS<(__3,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)

fn get_field_mut_(&mut self, _: TStr<__TS<(__3,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__3,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__3,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__3,)>>, GetFieldType<Self, TStr<__TS<(__3,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8> GetFieldMut<TStr<__TS<(__4,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)

fn get_field_mut_(&mut self, _: TStr<__TS<(__4,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__4,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__4,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__4,)>>, GetFieldType<Self, TStr<__TS<(__4,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8> GetFieldMut<TStr<__TS<(__5,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)

fn get_field_mut_(&mut self, _: TStr<__TS<(__5,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__5,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__5,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__5,)>>, GetFieldType<Self, TStr<__TS<(__5,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8> GetFieldMut<TStr<__TS<(__6,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)

fn get_field_mut_(&mut self, _: TStr<__TS<(__6,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__6,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__6,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__6,)>>, GetFieldType<Self, TStr<__TS<(__6,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8> GetFieldMut<TStr<__TS<(__7,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)

fn get_field_mut_(&mut self, _: TStr<__TS<(__7,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__7,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__7,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__7,)>>, GetFieldType<Self, TStr<__TS<(__7,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8> GetFieldMut<TStr<__TS<(__8,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8)

fn get_field_mut_(&mut self, _: TStr<__TS<(__8,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__8,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__8,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__8,)>>, GetFieldType<Self, TStr<__TS<(__8,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__3,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__3,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__3,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__3,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__3,)>>, GetFieldType<Self, TStr<__TS<(__3,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__4,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__4,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__4,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__4,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__4,)>>, GetFieldType<Self, TStr<__TS<(__4,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__5,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__5,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__5,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__5,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__5,)>>, GetFieldType<Self, TStr<__TS<(__5,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__6,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__6,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__6,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__6,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__6,)>>, GetFieldType<Self, TStr<__TS<(__6,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__7,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__7,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__7,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__7,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__7,)>>, GetFieldType<Self, TStr<__TS<(__7,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__8,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__8,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__8,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__8,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__8,)>>, GetFieldType<Self, TStr<__TS<(__8,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9> GetFieldMut<TStr<__TS<(__9,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9)

fn get_field_mut_(&mut self, _: TStr<__TS<(__9,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__9,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__9,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__9,)>>, GetFieldType<Self, TStr<__TS<(__9,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__3,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__3,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__3,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__3,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__3,)>>, GetFieldType<Self, TStr<__TS<(__3,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__4,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__4,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__4,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__4,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__4,)>>, GetFieldType<Self, TStr<__TS<(__4,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__5,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__5,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__5,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__5,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__5,)>>, GetFieldType<Self, TStr<__TS<(__5,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__6,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__6,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__6,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__6,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__6,)>>, GetFieldType<Self, TStr<__TS<(__6,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__7,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__7,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__7,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__7,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__7,)>>, GetFieldType<Self, TStr<__TS<(__7,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__8,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__8,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__8,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__8,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__8,)>>, GetFieldType<Self, TStr<__TS<(__8,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__9,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__9,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__9,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__9,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__9,)>>, GetFieldType<Self, TStr<__TS<(__9,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10> GetFieldMut<TStr<__TS<(__1, __0)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1, __0)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1, __0)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1, __0)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1, __0)>>, GetFieldType<Self, TStr<__TS<(__1, __0)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__0,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__0,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__0,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__0,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__0,)>>, GetFieldType<Self, TStr<__TS<(__0,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__1,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1,)>>, GetFieldType<Self, TStr<__TS<(__1,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__2,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__2,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__2,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__2,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__2,)>>, GetFieldType<Self, TStr<__TS<(__2,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__3,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__3,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__3,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__3,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__3,)>>, GetFieldType<Self, TStr<__TS<(__3,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__4,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__4,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__4,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__4,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__4,)>>, GetFieldType<Self, TStr<__TS<(__4,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__5,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__5,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__5,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__5,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__5,)>>, GetFieldType<Self, TStr<__TS<(__5,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__6,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__6,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__6,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__6,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__6,)>>, GetFieldType<Self, TStr<__TS<(__6,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__7,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__7,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__7,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__7,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__7,)>>, GetFieldType<Self, TStr<__TS<(__7,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__8,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__8,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__8,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__8,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__8,)>>, GetFieldType<Self, TStr<__TS<(__8,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__9,)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__9,)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__9,)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__9,)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__9,)>>, GetFieldType<Self, TStr<__TS<(__9,)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__1, __0)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1, __0)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1, __0)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1, __0)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1, __0)>>, GetFieldType<Self, TStr<__TS<(__1, __0)>>>>

impl<C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11> GetFieldMut<TStr<__TS<(__1, __1)>>> for (C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, C10, C11)

fn get_field_mut_(&mut self, _: TStr<__TS<(__1, __1)>>) -> &mut Self::Ty

unsafe fn get_field_raw_mut(
    this: *mut (),
    _: TStr<__TS<(__1, __1)>>
) -> *mut GetFieldType<Self, TStr<__TS<(__1, __1)>>>

fn get_field_raw_mut_fn(
    &self
) -> GetFieldRawMutFn<TStr<__TS<(__1, __1)>>, GetFieldType<Self, TStr<__TS<(__1, __1)>>>>

Loading content...

Implementors

impl<T, __F, __Ty> GetFieldMut<__F> for StrucWrapper<T> where
    StrucWrapper<T>: Sized,
    T: GetFieldMut<__F, Ty = __Ty>, 

fn get_field_mut_(&mut self, fname: __F) -> &mut __Ty

unsafe fn get_field_raw_mut(this: *mut (), fname: __F) -> *mut __Ty where
    Self: Sized, 

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<__F, __Ty>

impl<T: ?Sized, V, F> GetFieldMut<F> for VariantProxy<T, V> where
    T: GetVariantFieldMut<V, F>,
    V: IsTStr, 

fn get_field_mut_(&mut self, fname: F) -> &mut T::Ty

unsafe fn get_field_raw_mut(this: *mut (), fname: F) -> *mut T::Ty where
    Self: Sized, 

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<F, T::Ty>

Loading content...