Trait structural::field::rev_get_field::RevGetFieldImpl

pub trait RevGetFieldImpl<'a, This: ?Sized>: RevFieldErr<This> {
    fn rev_get_field(self, this: &'a This) -> Result<&'a Self::Ty, Self::Err>;
}

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

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

This is used by the StructuralExt::field_ method.

Use as bound

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

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

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

Example

This example demonstrates implementing RevGetFieldImpl to index a slice from the end.

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

struct FromEnd(usize);

impl IsSingleFieldPath for FromEnd{}

impl<'a,T> RevFieldType<[T]> for FromEnd {
    type Ty = T;
}
impl<'a,T> RevFieldErr<[T]> for FromEnd {
    type Err = FailedAccess;
}
impl<'a,T> RevGetFieldImpl<'a,[T]> for FromEnd {
    fn rev_get_field(self, this: &'a [T]) -> Result<&'a T, FailedAccess>{
        let len=this.len();
        this.get(len.wrapping_sub(self.0 + 1))
            .ok_or(FailedAccess)
    }
}

let slice=&[3,5,8,13][..];

assert_eq!( slice.field_(FromEnd(0)), Some(&13) );
assert_eq!( slice.field_(FromEnd(1)), Some(&8) );
assert_eq!( slice.field_(FromEnd(2)), Some(&5) );
assert_eq!( slice.field_(FromEnd(3)), Some(&3) );
assert_eq!( slice.field_(FromEnd(4)), None );

Required methods

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

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

Loading content...

Implementors

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...