[−][src]Struct structural::FieldPathSet
A list of field paths to access multiple fields,
whose uniqueness is determined by the U
type parameter.
This is the type that fp!(a, b.c, ::D.e, ::F)
constructs.
Construction
You can construct this using (not an exhaustive list):
-
fp
macro,when you access multiple fields (using=>
constructs aNestedFieldPathSet
instead). -
The
NEW
associated constant,ifT
implementscore_extensions::ConstDefault
(reexported instructural::reexports::ConstDefault
)
Uniqueness
If the U
type parameter is a:
-
UniquePaths
: all the field paths are unique, and this can be passed toStructuralExt::fields_mut
andStructuralExt::into_fields
. -
AliasedPaths
: there might be repeated field paths. This cannot be passed toStructuralExt::fields_mut
, because it might borrow the same field mutably twice. This can also not be passed toStructuralExt::into_fields
, because a field cannot generally be moved out twice.
Drop Types
To make all the inherent methods in this type const fn
this type wraps the T
inside a ManuallyDrop
,
which means that T
won't be dropped inside.
If that is a problem don't construct a FieldPathSet
with a T
that owns some resource.
Examples
You can look for examples of using this in the multi-field
StructuralExt
methods, like fields
,fields_mut
, and into_fields
.
Implementations
impl<T> FieldPathSet<(T,), UniquePaths>
[src]
impl<T> FieldPathSet<T, AliasedPaths>
[src]
pub const fn many(paths: T) -> Self
[src]
Constructs a FieldPathSet from a tuple of up to 8 field paths.
Note that this doesn't enforce that its input is in fact a tuple of
up to 8 field paths (because const fn
can't have bounds yet).
To be able to access multiple fields mutably/by value at the same time,
you must call the unsafe .upgrade()
method.
To access more than 8 fields, you must use the large constructor.
impl<T> FieldPathSet<LargePathSet<T>, AliasedPaths>
[src]
pub const fn large(paths: T) -> Self
[src]
Constructs a FieldPathSet from a tuple of tuples of field paths, for accessing up to 64 fields.
Note that this doesn't enforce that its input is in fact a
tuple of tuples of field paths (because const fn
can't have bounds yet).
To be able to access multiple fields mutably/by value at the same time,
you must call the unsafe .upgrade()
method.
Example
This example demonstrates calling this function with 8 and 9 field paths,
as well as the return value of StructuralExt
methods for both path sets.
Accessing over 8 fields returns a tuple of tuples (8 fields each).
You can also destructure the tuple returned by accessor methods by using
the field_pat
macro, usable from 0 to 64 fields.
use structural::{ FieldPathSet, StructuralExt, path_tuple, ts }; let array = [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]; { let path8 = FieldPathSet::large(path_tuple!( ts!(0), ts!(1), ts!(2), ts!(3), ts!(4), ts!(5), ts!(6), ts!(7), )); assert_eq!( array.cloned_fields(path8), (10, 11, 12, 13, 14, 15, 16, 17), ); } { let path9 = FieldPathSet::large(path_tuple!( ts!(0), ts!(1), ts!(2), ts!(3), ts!(4), ts!(5), ts!(6), ts!(7), ts!(8), )); assert_eq!( array.cloned_fields(path9), ( (10, 11, 12, 13, 14, 15, 16, 17), (18,), ), ); }
impl<T> FieldPathSet<T, AliasedPaths> where
T: ConstDefault,
[src]
T: ConstDefault,
pub const NEW: Self
[src]
Constructs a FieldPathSet
.
This can also be used to construct a FieldPathSet<T, UniquePaths>
in a context where T
can be inferred,
by doing unsafe{ FieldPathSet::NEW.upgrade_unchecked() }
(read the docs for upgrade_unchecked
first).
impl<T, U> FieldPathSet<T, U> where
T: ConstDefault,
[src]
T: ConstDefault,
pub const NEW_ALIASED: FieldPathSet<T, AliasedPaths>
[src]
This can be used to construct a FieldPathSet<T, UniquePaths>
from a type alias,
by doing unsafe{ FOO::NEW_ALIASED.upgrade_unchecked() }
(read the docs for upgrade_unchecked
first).
impl<T> FieldPathSet<T, UniquePaths>
[src]
pub const fn downgrade(self) -> FieldPathSet<T, AliasedPaths>
[src]
Converts a FieldPathSet<T,UniquePaths>
to a FieldPathSet<T,AliasedPaths>
impl<T> FieldPathSet<T, AliasedPaths>
[src]
pub const unsafe fn upgrade_unchecked(self) -> FieldPathSet<T, UniquePaths>
[src]
Converts a FieldPathSet<T,AliasedPaths>
to a FieldPathSet<T,UniquePaths>
Safety
You must ensure that all the field paths in the T
type parameter are unique,
there must be no field path that is a prefix of any other field path.
pub const unsafe fn set_uniqueness<U>(self) -> FieldPathSet<T, U>
[src]
Converts a FieldPathSet<T,AliasedPaths>
to a FieldPathSet<T,U>
Safety
You must ensure that if U==UniquePaths
,
then all the field paths in the T
type parameter are unique,
there must be no field path that is a prefix of any other field path.
impl<T, U> FieldPathSet<T, U>
[src]
pub const fn into_paths(self) -> T
[src]
Gets the tuple of field paths out of this FieldPathSet.
impl<T, U> FieldPathSet<(T,), U>
[src]
pub fn into_path(self) -> T
[src]
Converts a FieldPathSet
containing a single field path into that field path.
impl<T, U> FieldPathSet<T, U>
[src]
pub fn push<O, Out>(self, _other: O) -> FieldPathSet<Out, AliasedPaths> where
Self: PushBack<O, Output = FieldPathSet<Out, AliasedPaths>>,
FieldPathSet<Out, AliasedPaths>: ConstDefault,
[src]
Self: PushBack<O, Output = FieldPathSet<Out, AliasedPaths>>,
FieldPathSet<Out, AliasedPaths>: ConstDefault,
Constructs a new FieldPathSet with _other
appended at the end.
Example argumentsfp!(a)
/fp!(a.b.c)
/fp!(::foo)
/fp!(::bar.baz.bam)
pub fn append<T2, U2>(
self,
_other: FieldPathSet<T2, U2>
) -> FieldPathSet<AppendOut<T, T2>, AliasedPaths> where
T: Append<T2>,
FieldPathSet<AppendOut<T, T2>, AliasedPaths>: ConstDefault,
[src]
self,
_other: FieldPathSet<T2, U2>
) -> FieldPathSet<AppendOut<T, T2>, AliasedPaths> where
T: Append<T2>,
FieldPathSet<AppendOut<T, T2>, AliasedPaths>: ConstDefault,
Constructs a new FieldPathSet with the _other
FieldPathSet
appended at the end.
Trait Implementations
impl<T, T2, U, U2> Append<FieldPathSet<T2, U2>> for FieldPathSet<T, U> where
T: Append<T2>,
[src]
T: Append<T2>,
type Output = FieldPathSet<AppendOut<T, T2>, AliasedPaths>
The return value of this trait.
impl<T: Clone, U: Clone> Clone for FieldPathSet<T, U>
[src]
fn clone(&self) -> FieldPathSet<T, U>
[src]
fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<T> ConstDefault for FieldPathSet<T, AliasedPaths> where
T: ConstDefault,
[src]
T: ConstDefault,
impl<T: Copy, U: Copy> Copy for FieldPathSet<T, U>
[src]
impl<T: Debug, U: Debug> Debug for FieldPathSet<T, U>
[src]
impl<T> Default for FieldPathSet<T, AliasedPaths> where
T: Default,
[src]
T: Default,
impl<T, U> Eq for FieldPathSet<T, U>
[src]
impl<F, U> IntoAliasing for FieldPathSet<F, U>
[src]
type Output = FieldPathSet<F, AliasedPaths>
The return value of this trait.
impl<T, U> IsMultiFieldPath for FieldPathSet<T, U>
[src]
type PathUniqueness = U
Whether the paths in the set can contain duplicate paths. Read more
impl<T, U> IsSingleFieldPath for FieldPathSet<(T,), U>
[src]
impl<T, U> Ord for FieldPathSet<T, U>
[src]
fn cmp(&self, _other: &Self) -> Ordering
[src]
#[must_use]fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]fn clamp(self, min: Self, max: Self) -> Self
[src]
impl<T, U> PartialEq<FieldPathSet<T, U>> for FieldPathSet<T, U>
[src]
impl<T, U> PartialOrd<FieldPathSet<T, U>> for FieldPathSet<T, U>
[src]
fn partial_cmp(&self, _other: &Self) -> Option<Ordering>
[src]
#[must_use]fn lt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn le(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn gt(&self, other: &Rhs) -> bool
1.0.0[src]
#[must_use]fn ge(&self, other: &Rhs) -> bool
1.0.0[src]
impl<T, U, P, U2> PushBack<FieldPathSet<(P,), U2>> for FieldPathSet<T, U> where
T: PushBack<P>,
[src]
T: PushBack<P>,
type Output = FieldPathSet<PushBackOut<T, P>, AliasedPaths>
The return value of this trait.
impl<T, U, P> PushBack<NestedFieldPath<P>> for FieldPathSet<T, U> where
T: PushBack<NestedFieldPath<P>>,
[src]
T: PushBack<NestedFieldPath<P>>,
type Output = FieldPathSet<PushBackOut<T, NestedFieldPath<P>>, AliasedPaths>
The return value of this trait.
impl<This, T, U> RevFieldErr<This> for FieldPathSet<(T,), U> where
This: ?Sized,
T: RevFieldErr<This>,
[src]
This: ?Sized,
T: RevFieldErr<This>,
impl<This, T, U> RevFieldType<This> for FieldPathSet<(T,), U> where
This: ?Sized,
T: RevFieldType<This>,
[src]
This: ?Sized,
T: RevFieldType<This>,
impl<'a, This: ?Sized, T, U> RevGetFieldImpl<'a, This> for FieldPathSet<(T,), U> where
This: 'a,
T: RevGetFieldImpl<'a, This>,
[src]
This: 'a,
T: RevGetFieldImpl<'a, This>,
impl<'a, This: ?Sized, T, U> RevGetFieldMutImpl<'a, This> for FieldPathSet<(T,), U> where
This: 'a,
T: RevGetFieldMutImpl<'a, This>,
[src]
This: 'a,
T: RevGetFieldMutImpl<'a, This>,
fn rev_get_field_mut(self, this: &'a mut This) -> Result<&'a mut T::Ty, T::Err>
[src]
unsafe fn rev_get_field_raw_mut(
self,
this: *mut This
) -> Result<*mut T::Ty, T::Err>
[src]
self,
this: *mut This
) -> Result<*mut T::Ty, T::Err>
impl<'a, This: ?Sized, F0, E0, T0, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0,), U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>,)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0,)>, U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>,)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5), U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>, Result<&'a T5, E5>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5)>, U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>, Result<&'a T5, E5>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
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, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>,
T6: 'a,
E6: IsFieldErr,
Result<&'a T6, E6>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>,
T6: 'a,
E6: IsFieldErr,
Result<&'a T6, E6>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>, Result<&'a T5, E5>, Result<&'a T6, E6>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
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, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6)>, U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>,
T6: 'a,
E6: IsFieldErr,
Result<&'a T6, E6>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>,
T6: 'a,
E6: IsFieldErr,
Result<&'a T6, E6>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>, Result<&'a T5, E5>, Result<&'a T6, E6>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
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, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>,
T6: 'a,
E6: IsFieldErr,
Result<&'a T6, E6>: NormalizeFields,
F7: RevGetFieldImpl<'a, This, Ty = T7, Err = E7>,
T7: 'a,
E7: IsFieldErr,
Result<&'a T7, E7>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>,
T6: 'a,
E6: IsFieldErr,
Result<&'a T6, E6>: NormalizeFields,
F7: RevGetFieldImpl<'a, This, Ty = T7, Err = E7>,
T7: 'a,
E7: IsFieldErr,
Result<&'a T7, E7>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>, Result<&'a T5, E5>, Result<&'a T6, E6>, Result<&'a T7, E7>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
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, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>,
T6: 'a,
E6: IsFieldErr,
Result<&'a T6, E6>: NormalizeFields,
F7: RevGetFieldImpl<'a, This, Ty = T7, Err = E7>,
T7: 'a,
E7: IsFieldErr,
Result<&'a T7, E7>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
F5: RevGetFieldImpl<'a, This, Ty = T5, Err = E5>,
T5: 'a,
E5: IsFieldErr,
Result<&'a T5, E5>: NormalizeFields,
F6: RevGetFieldImpl<'a, This, Ty = T6, Err = E6>,
T6: 'a,
E6: IsFieldErr,
Result<&'a T6, E6>: NormalizeFields,
F7: RevGetFieldImpl<'a, This, Ty = T7, Err = E7>,
T7: 'a,
E7: IsFieldErr,
Result<&'a T7, E7>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>, Result<&'a T5, E5>, Result<&'a T6, E6>, Result<&'a T7, E7>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized + 'a, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(), U>
[src]
type UnnormFields = ()
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, _this: &'a This)
[src]
impl<'a, This: ?Sized, F0, E0, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0,)>, U> where
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
[src]
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
type UnnormFields = E0
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, F1, E1, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1)>, U> where
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
[src]
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
type UnnormFields = (E0, E1)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, F1, E1, F2, E2, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2)>, U> where
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
[src]
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
type UnnormFields = (E0, E1, E2)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1), U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, F1, E1, F2, E2, F3, E3, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3)>, U> where
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
[src]
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
type UnnormFields = (E0, E1, E2, E3)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4)>, U> where
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>,
E4: 'a + NormalizeFields,
[src]
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>,
E4: 'a + NormalizeFields,
type UnnormFields = (E0, E1, E2, E3, E4)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5)>, U> where
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>,
E4: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F5>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E5>,
E5: 'a + NormalizeFields,
[src]
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>,
E4: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F5>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E5>,
E5: 'a + NormalizeFields,
type UnnormFields = (E0, E1, E2, E3, E4, E5)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, F6, E6, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6)>, U> where
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>,
E4: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F5>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E5>,
E5: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F6>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E6>,
E6: 'a + NormalizeFields,
[src]
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>,
E4: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F5>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E5>,
E5: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F6>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E6>,
E6: 'a + NormalizeFields,
type UnnormFields = (E0, E1, E2, E3, E4, E5, E6)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, F6, E6, F7, E7, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, U> where
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>,
E4: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F5>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E5>,
E5: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F6>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E6>,
E6: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F7>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E7>,
E7: 'a + NormalizeFields,
[src]
This: 'a,
FieldPathSet<SmallPathSet<F0>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E0>,
E0: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F1>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E1>,
E1: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F2>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E2>,
E2: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F3>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E3>,
E3: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F4>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E4>,
E4: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F5>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E5>,
E5: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F6>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E6>,
E6: 'a + NormalizeFields,
FieldPathSet<SmallPathSet<F7>, AliasedPaths>: RevGetMultiFieldImpl<'a, This, UnnormFields = E7>,
E7: 'a + NormalizeFields,
type UnnormFields = (E0, E1, E2, E3, E4, E5, E6, E7)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized + 'a, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<LargePathSet<()>, U>
[src]
type UnnormFields = ()
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, _this: &'a This)
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1)>, U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2), U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2)>, U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3), U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3)>, U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<(F0, F1, F2, F3, F4), U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
impl<'a, This: ?Sized, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, U> RevGetMultiFieldImpl<'a, This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4)>, U> where
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
[src]
This: 'a,
F0: RevGetFieldImpl<'a, This, Ty = T0, Err = E0>,
T0: 'a,
E0: IsFieldErr,
Result<&'a T0, E0>: NormalizeFields,
F1: RevGetFieldImpl<'a, This, Ty = T1, Err = E1>,
T1: 'a,
E1: IsFieldErr,
Result<&'a T1, E1>: NormalizeFields,
F2: RevGetFieldImpl<'a, This, Ty = T2, Err = E2>,
T2: 'a,
E2: IsFieldErr,
Result<&'a T2, E2>: NormalizeFields,
F3: RevGetFieldImpl<'a, This, Ty = T3, Err = E3>,
T3: 'a,
E3: IsFieldErr,
Result<&'a T3, E3>: NormalizeFields,
F4: RevGetFieldImpl<'a, This, Ty = T4, Err = E4>,
T4: 'a,
E4: IsFieldErr,
Result<&'a T4, E4>: NormalizeFields,
type UnnormFields = (Result<&'a T0, E0>, Result<&'a T1, E1>, Result<&'a T2, E2>, Result<&'a T3, E3>, Result<&'a T4, E4>)
A collection of Results<&'a _,_>
s referencing fields.
fn rev_get_multi_field_impl(self, this: &'a This) -> Self::UnnormFields
[src]
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,
[src]
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>,)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>,)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>,)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>,)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
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>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
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>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
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>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
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>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
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>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
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>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
impl<'a, This: ?Sized + 'a> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<(), UniquePaths>
[src]
type UnnormFieldsMut = ()
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = ()
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(self, _this: &'a mut This)
[src]
unsafe fn rev_get_multi_field_raw_mut_impl(self, _this: *mut This)
[src]
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>,
[src]
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
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = T0
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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>,
[src]
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)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (T0, T1)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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>,
[src]
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)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (T0, T1, T2)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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>,
[src]
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)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (T0, T1, T2, T3)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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>,
[src]
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)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (T0, T1, T2, T3, T4)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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>,
[src]
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)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (T0, T1, T2, T3, T4, T5)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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>,
[src]
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)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (T0, T1, T2, T3, T4, T5, T6)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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>,
[src]
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)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (T0, T1, T2, T3, T4, T5, T6, T7)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
impl<'a, This: ?Sized + 'a> RevGetMultiFieldMutImpl<'a, This> for FieldPathSet<LargePathSet<()>, UniquePaths>
[src]
type UnnormFieldsMut = ()
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = ()
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(self, _this: &'a mut This)
[src]
unsafe fn rev_get_multi_field_raw_mut_impl(self, _this: *mut This)
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
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,
[src]
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>)
This is usually a tuple of Result<&mut _,E: IsFieldErr>
s.
type UnnormFieldsRawMut = (Result<*mut T0, E0>, Result<*mut T1, E1>, Result<*mut T2, E2>, Result<*mut T3, E3>, Result<*mut T4, E4>)
This is usually a tuple of Result<*mut _,E: IsFieldErr>
s.
fn rev_get_multi_field_mut_impl(
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
[src]
self,
this: &'a mut This
) -> Self::UnnormFieldsMut
unsafe fn rev_get_multi_field_raw_mut_impl(
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
[src]
self,
this: *mut This
) -> Self::UnnormFieldsRawMut
impl<This, T, U> RevIntoFieldImpl<This> for FieldPathSet<(T,), U> where
This: ?Sized,
T: RevIntoFieldImpl<This>,
[src]
This: ?Sized,
T: RevIntoFieldImpl<This>,
impl<'a, This, F0, E0, T0> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0,), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>,)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0,)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>,)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>, Result<T5, E5>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>, Result<T5, E5>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>, Result<T5, E5>, Result<T6, E6>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>, Result<T5, E5>, Result<T6, E6>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>,
Result<T7, E7>: NormalizeFields,
E7: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>,
Result<T7, E7>: NormalizeFields,
E7: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>, Result<T5, E5>, Result<T6, E6>, Result<T7, E7>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>,
Result<T7, E7>: NormalizeFields,
E7: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>,
Result<T7, E7>: NormalizeFields,
E7: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>, Result<T5, E5>, Result<T6, E6>, Result<T7, E7>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This> RevIntoMultiFieldImpl<This> for FieldPathSet<(), UniquePaths>
[src]
type UnnormIntoFields = ()
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, _this: This)
[src]
impl<'a, This, F0, E0> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0,)>, UniquePaths> where
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
[src]
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
type UnnormIntoFields = E0
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, F1, E1> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1)>, UniquePaths> where
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
[src]
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
type UnnormIntoFields = (E0, E1)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, F1, E1, F2, E2> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2)>, UniquePaths> where
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
[src]
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
type UnnormIntoFields = (E0, E1, E2)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3)>, UniquePaths> where
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
[src]
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
type UnnormIntoFields = (E0, E1, E2, E3)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4)>, UniquePaths> where
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>,
E4: NormalizeFields,
[src]
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>,
E4: NormalizeFields,
type UnnormIntoFields = (E0, E1, E2, E3, E4)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5)>, UniquePaths> where
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>,
E4: NormalizeFields,
FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E5>,
E5: NormalizeFields,
[src]
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>,
E4: NormalizeFields,
FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E5>,
E5: NormalizeFields,
type UnnormIntoFields = (E0, E1, E2, E3, E4, E5)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, F6, E6> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6)>, UniquePaths> where
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>,
E4: NormalizeFields,
FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E5>,
E5: NormalizeFields,
FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E6>,
E6: NormalizeFields,
[src]
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>,
E4: NormalizeFields,
FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E5>,
E5: NormalizeFields,
FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E6>,
E6: NormalizeFields,
type UnnormIntoFields = (E0, E1, E2, E3, E4, E5, E6)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, F1, E1, F2, E2, F3, E3, F4, E4, F5, E5, F6, E6, F7, E7> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, UniquePaths> where
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>,
E4: NormalizeFields,
FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E5>,
E5: NormalizeFields,
FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E6>,
E6: NormalizeFields,
FieldPathSet<SmallPathSet<F7>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E7>,
E7: NormalizeFields,
[src]
This: DropFields,
FieldPathSet<SmallPathSet<F0>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E0>,
E0: NormalizeFields,
FieldPathSet<SmallPathSet<F1>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E1>,
E1: NormalizeFields,
FieldPathSet<SmallPathSet<F2>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E2>,
E2: NormalizeFields,
FieldPathSet<SmallPathSet<F3>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E3>,
E3: NormalizeFields,
FieldPathSet<SmallPathSet<F4>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E4>,
E4: NormalizeFields,
FieldPathSet<SmallPathSet<F5>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E5>,
E5: NormalizeFields,
FieldPathSet<SmallPathSet<F6>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E6>,
E6: NormalizeFields,
FieldPathSet<SmallPathSet<F7>, UniquePaths>: RevMoveOutMultiFieldImpl<This, UnnormIntoFields = E7>,
E7: NormalizeFields,
type UnnormIntoFields = (E0, E1, E2, E3, E4, E5, E6, E7)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This> RevIntoMultiFieldImpl<This> for FieldPathSet<LargePathSet<()>, UniquePaths>
[src]
type UnnormIntoFields = ()
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, _this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevIntoMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevIntoMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
type UnnormIntoFields = (Result<T0, E0>, Result<T1, E1>, Result<T2, E2>, Result<T3, E3>, Result<T4, E4>)
This is usually a tuple of Result<_, E: IsFieldErr>
s.
fn rev_into_multi_field_impl(self, this: This) -> Self::UnnormIntoFields
[src]
impl<This, T, U> RevMoveOutFieldImpl<This> for FieldPathSet<(T,), U> where
This: ?Sized,
T: RevMoveOutFieldImpl<This>,
[src]
This: ?Sized,
T: RevMoveOutFieldImpl<This>,
unsafe fn rev_move_out_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Result<Self::Ty, Self::Err> where
T::Ty: Sized,
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Result<Self::Ty, Self::Err> where
T::Ty: Sized,
impl<'a, This, F0, E0, T0> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0,), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0,)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>,
Result<T7, E7>: NormalizeFields,
E7: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>,
Result<T7, E7>: NormalizeFields,
E7: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4, F5, E5, T5, F6, E6, T6, F7, E7, T7> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>,
Result<T7, E7>: NormalizeFields,
E7: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
F5: RevMoveOutFieldImpl<This, Ty = T5, Err = E5>,
Result<T5, E5>: NormalizeFields,
E5: IsFieldErr,
F6: RevMoveOutFieldImpl<This, Ty = T6, Err = E6>,
Result<T6, E6>: NormalizeFields,
E6: IsFieldErr,
F7: RevMoveOutFieldImpl<This, Ty = T7, Err = E7>,
Result<T7, E7>: NormalizeFields,
E7: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(), UniquePaths>
[src]
unsafe fn rev_move_out_multi_field(
self,
_this: &mut This,
_moved: &mut MovedOutFields
)
[src]
self,
_this: &mut This,
_moved: &mut MovedOutFields
)
impl<'a, This, F0, E0, T0, F1, E1, T1> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevMoveOutMultiFieldImpl<This> for FieldPathSet<(F0, F1, F2, F3, F4), UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<'a, This, F0, E0, T0, F1, E1, T1, F2, E2, T2, F3, E3, T3, F4, E4, T4> RevMoveOutMultiFieldImpl<This> for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4)>, UniquePaths> where
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
[src]
This: DropFields,
F0: RevMoveOutFieldImpl<This, Ty = T0, Err = E0>,
Result<T0, E0>: NormalizeFields,
E0: IsFieldErr,
F1: RevMoveOutFieldImpl<This, Ty = T1, Err = E1>,
Result<T1, E1>: NormalizeFields,
E1: IsFieldErr,
F2: RevMoveOutFieldImpl<This, Ty = T2, Err = E2>,
Result<T2, E2>: NormalizeFields,
E2: IsFieldErr,
F3: RevMoveOutFieldImpl<This, Ty = T3, Err = E3>,
Result<T3, E3>: NormalizeFields,
E3: IsFieldErr,
F4: RevMoveOutFieldImpl<This, Ty = T4, Err = E4>,
Result<T4, E4>: NormalizeFields,
E4: IsFieldErr,
unsafe fn rev_move_out_multi_field(
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
[src]
self,
this: &mut This,
moved: &mut MovedOutFields
) -> Self::UnnormIntoFields
impl<F0, U> ShallowFieldPath for FieldPathSet<(F0,), U> where
F0: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
impl<F0, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0,)>, U> where
F0: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, F5, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3, F4, F5), U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, F5, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5)>, U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, F5, F6, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6), U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
F6: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
F6: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, F5, F6, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6)>, U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
F6: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
F6: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, F5, F6, F7, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3, F4, F5, F6, F7), U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
F6: ShallowFieldPath,
F7: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
F6: ShallowFieldPath,
F7: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, F5, F6, F7, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
F6: ShallowFieldPath,
F7: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
F5: ShallowFieldPath,
F6: ShallowFieldPath,
F7: ShallowFieldPath,
impl<U> ShallowFieldPath for FieldPathSet<(), U>
[src]
impl<F0, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0,)>, U> where
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
[src]
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
impl<F0, F1, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1)>, U> where
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
[src]
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
impl<F0, F1, F2, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2)>, U> where
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
[src]
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
impl<F0, F1, U> ShallowFieldPath for FieldPathSet<(F0, F1), U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
impl<F0, F1, F2, F3, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3)>, U> where
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
[src]
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4)>, U> where
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath,
[src]
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, F5, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5)>, U> where
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F5>, U>: ShallowFieldPath,
[src]
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F5>, U>: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, F5, F6, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6)>, U> where
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F5>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F6>, U>: ShallowFieldPath,
[src]
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F5>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F6>, U>: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, F5, F6, F7, U> ShallowFieldPath for FieldPathSet<LargePathSet<(F0, F1, F2, F3, F4, F5, F6, F7)>, U> where
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F5>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F6>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F7>, U>: ShallowFieldPath,
[src]
FieldPathSet<SmallPathSet<F0>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F1>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F2>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F3>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F4>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F5>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F6>, U>: ShallowFieldPath,
FieldPathSet<SmallPathSet<F7>, U>: ShallowFieldPath,
impl<U> ShallowFieldPath for FieldPathSet<LargePathSet<()>, U>
[src]
impl<F0, F1, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0, F1)>, U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
impl<F0, F1, F2, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2), U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
impl<F0, F1, F2, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0, F1, F2)>, U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
impl<F0, F1, F2, F3, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3), U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
impl<F0, F1, F2, F3, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0, F1, F2, F3)>, U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, U> ShallowFieldPath for FieldPathSet<(F0, F1, F2, F3, F4), U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
impl<F0, F1, F2, F3, F4, U> ShallowFieldPath for FieldPathSet<SmallPathSet<(F0, F1, F2, F3, F4)>, U> where
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
[src]
F0: ShallowFieldPath,
F1: ShallowFieldPath,
F2: ShallowFieldPath,
F3: ShallowFieldPath,
F4: ShallowFieldPath,
Auto Trait Implementations
impl<T, U> RefUnwindSafe for FieldPathSet<T, U> where
T: RefUnwindSafe,
U: RefUnwindSafe,
T: RefUnwindSafe,
U: RefUnwindSafe,
impl<T, U> Send for FieldPathSet<T, U> where
T: Send,
U: Send,
T: Send,
U: Send,
impl<T, U> Sync for FieldPathSet<T, U> where
T: Sync,
U: Sync,
T: Sync,
U: Sync,
impl<T, U> Unpin for FieldPathSet<T, U> where
T: Unpin,
U: Unpin,
T: Unpin,
U: Unpin,
impl<T, U> UnwindSafe for FieldPathSet<T, U> where
T: UnwindSafe,
U: UnwindSafe,
T: UnwindSafe,
U: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<This, T> Array0<T> for This where
This: ?Sized,
[src]
This: ?Sized,
impl<This, V, T> Array0Variant<T, V> for This where
This: ?Sized,
[src]
This: ?Sized,
impl<This, T> ArrayMove0<T> for This where
This: ?Sized,
[src]
This: ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<This, T> IntoStructural<T> for This where
T: FromStructural<This>,
[src]
T: FromStructural<This>,
fn into_structural(Self) -> T
[src]
impl<'a, Path, This> OptRevGetField<'a, This> for Path where
Path: RevGetFieldImpl<'a, This, Err = FailedAccess>,
[src]
Path: RevGetFieldImpl<'a, This, Err = FailedAccess>,
impl<'a, Path, This> OptRevGetFieldMut<'a, This> for Path where
Path: RevGetFieldMutImpl<'a, This, Err = FailedAccess>,
[src]
Path: RevGetFieldMutImpl<'a, This, Err = FailedAccess>,
impl<Path, This> OptRevIntoField<This> for Path where
Path: RevIntoFieldImpl<This, Err = FailedAccess>,
[src]
Path: RevIntoFieldImpl<This, Err = FailedAccess>,
impl<'a, Path, This> OptRevIntoFieldMut<'a, This> for Path where
Path: OptRevIntoField<This> + OptRevGetFieldMut<'a, This>,
[src]
Path: OptRevIntoField<This> + OptRevGetFieldMut<'a, This>,
impl<'a, Path, This> OptRevIntoFieldRef<'a, This> for Path where
Path: OptRevIntoField<This> + OptRevGetFieldMut<'a, This>,
[src]
Path: OptRevIntoField<This> + OptRevGetFieldMut<'a, This>,
impl<'a, Path, This> RevGetField<'a, This> for Path where
Path: RevGetFieldImpl<'a, This, Err = InfallibleAccess>,
[src]
Path: RevGetFieldImpl<'a, This, Err = InfallibleAccess>,
impl<'a, Path, This> RevGetFieldMut<'a, This> for Path where
Path: RevGetFieldMutImpl<'a, This, Err = InfallibleAccess>,
[src]
Path: RevGetFieldMutImpl<'a, This, Err = InfallibleAccess>,
impl<'a, This, Path> RevGetMultiField<'a, This> for Path where
Path: RevGetMultiFieldImpl<'a, This>,
This: 'a + ?Sized,
[src]
Path: RevGetMultiFieldImpl<'a, This>,
This: 'a + ?Sized,
type Fields = <<Path as RevGetMultiFieldImpl<'a, This>>::UnnormFields as NormalizeFields>::Output
This is usually a tuple of Option<&_>
s and &_
s.
fn rev_get_multi_field(
Self,
&'a This
) -> <Path as RevGetMultiField<'a, This>>::Fields
[src]
Self,
&'a This
) -> <Path as RevGetMultiField<'a, This>>::Fields
impl<'a, This, Path> RevGetMultiFieldMut<'a, This> for Path where
Path: RevGetMultiFieldMutImpl<'a, This>,
This: 'a + ?Sized,
[src]
Path: RevGetMultiFieldMutImpl<'a, This>,
This: 'a + ?Sized,
type FieldsMut = <<Path as RevGetMultiFieldMutImpl<'a, This>>::UnnormFieldsMut as NormalizeFields>::Output
This is usually a tuple of Option<&mut _>
s and &mut _
s.
type FieldsRawMut = <<Path as RevGetMultiFieldMutImpl<'a, This>>::UnnormFieldsRawMut as NormalizeFields>::Output
This is usually a tuple of Option<*mut _>
s and *mut _
s.
fn rev_get_multi_field_mut(
Self,
&'a mut This
) -> <Path as RevGetMultiFieldMut<'a, This>>::FieldsMut
[src]
Self,
&'a mut This
) -> <Path as RevGetMultiFieldMut<'a, This>>::FieldsMut
unsafe fn rev_get_multi_field_raw_mut(
Self,
*mut This
) -> <Path as RevGetMultiFieldMut<'a, This>>::FieldsRawMut
[src]
Self,
*mut This
) -> <Path as RevGetMultiFieldMut<'a, This>>::FieldsRawMut
impl<Path, This> RevIntoField<This> for Path where
Path: RevIntoFieldImpl<This, Err = InfallibleAccess>,
[src]
Path: RevIntoFieldImpl<This, Err = InfallibleAccess>,
impl<'a, Path, This> RevIntoFieldMut<'a, This> for Path where
Path: RevIntoField<This> + RevGetFieldMut<'a, This>,
[src]
Path: RevIntoField<This> + RevGetFieldMut<'a, This>,
impl<'a, Path, This> RevIntoFieldRef<'a, This> for Path where
Path: RevIntoField<This> + RevGetFieldMut<'a, This>,
[src]
Path: RevIntoField<This> + RevGetFieldMut<'a, This>,
impl<This, Path> RevIntoMultiField<This> for Path where
Path: RevIntoMultiFieldImpl<This>,
[src]
Path: RevIntoMultiFieldImpl<This>,
type IntoFields = <<Path as RevIntoMultiFieldImpl<This>>::UnnormIntoFields as NormalizeFields>::Output
This is usually a tuple of Option<T>
s and T
s.
fn rev_into_multi_field(
Self,
This
) -> <Path as RevIntoMultiField<This>>::IntoFields
[src]
Self,
This
) -> <Path as RevIntoMultiField<This>>::IntoFields
impl<T> SelfOps for T where
T: ?Sized,
[src]
T: ?Sized,
const T: PhantomData<fn() -> Self>
[src]
const T_D: PhantomData<Self>
[src]
fn assert_ty(self, _other: PhantomData<fn() -> Self>) -> Self
[src]
fn assert_ty_ref(&self, _other: PhantomData<fn() -> Self>) -> &Self
[src]
fn assert_ty_mut(&mut self, _other: PhantomData<fn() -> Self>) -> &mut Self
[src]
fn ty_(&self) -> PhantomData<fn() -> Self>
[src]
fn ty_d(&self) -> PhantomData<Self>
[src]
fn ty_inv(&self) -> PhantomData<fn(Self) -> Self>
[src]
fn ty_inv_ref(&self) -> PhantomData<Cell<&Self>>
[src]
fn eq_id(&self, other: &Self) -> bool
[src]
fn piped<F, U>(self, f: F) -> U where
F: FnOnce(Self) -> U,
[src]
F: FnOnce(Self) -> U,
fn piped_ref<'a, F, U>(&'a self, f: F) -> U where
F: FnOnce(&'a Self) -> U,
[src]
F: FnOnce(&'a Self) -> U,
fn piped_mut<'a, F, U>(&'a mut self, f: F) -> U where
F: FnOnce(&'a mut Self) -> U,
[src]
F: FnOnce(&'a mut Self) -> U,
fn mutated<F>(self, f: F) -> Self where
F: FnOnce(&mut Self),
[src]
F: FnOnce(&mut Self),
fn observe<F>(self, f: F) -> Self where
F: FnOnce(&Self),
[src]
F: FnOnce(&Self),
fn into_<T>(self, PhantomData<fn() -> T>) -> T where
Self: Into<T>,
[src]
Self: Into<T>,
fn as_ref_<T>(&self) -> &T where
Self: AsRef<T>,
T: ?Sized,
[src]
Self: AsRef<T>,
T: ?Sized,
fn as_mut_<T>(&mut self) -> &mut T where
Self: AsMut<T>,
T: ?Sized,
[src]
Self: AsMut<T>,
T: ?Sized,
fn drop_(self)
[src]
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
fn to_owned(&self) -> T
[src]
fn clone_into(&self, target: &mut T)
[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The error type returned when the conversion fails.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<This, T> TryIntoStructural<T> for This where
T: TryFromStructural<This>,
[src]
T: TryFromStructural<This>,
type Error = <T as TryFromStructural<This>>::Error
The error parameter of TryFromError
, returned from try_into_structural
on conversion error. Read more
fn try_into_structural(
Self
) -> Result<T, TryFromError<This, <This as TryIntoStructural<T>>::Error>>
[src]
Self
) -> Result<T, TryFromError<This, <This as TryIntoStructural<T>>::Error>>
impl<T> TypeIdentity for T where
T: ?Sized,
[src]
T: ?Sized,
type Type = T
The same type as Self. Read more
fn into_type_val(self) -> Self::Type where
Self::Type: Sized,
[src]
Self::Type: Sized,
fn into_type_ref(&self) -> &Self::Type
[src]
fn into_type_mut(&mut self) -> &mut Self::Type
[src]
fn into_type_box(self: Box<Self>) -> Box<Self::Type>
[src]
fn into_type_arc(this: Arc<Self>) -> Arc<Self::Type>
[src]
fn into_type_rc(this: Rc<Self>) -> Rc<Self::Type>
[src]
fn from_type_val(this: Self::Type) -> Self where
Self::Type: Sized,
[src]
Self::Type: Sized,