Struct VariantField

pub struct VariantField<V, F> {
    pub variant: V,
    pub field: F,
}

This allows accessing the F field inside the V enum variant.

This is the type that fp!(::Foo.bar) constructs.

Both the V and F type parameters are TStr.

Construction

You can construct this using (not an exhaustive list):

• The fp macro, with fp!(::Foo.bar)

• The VariantField{variant,field} struct literal

• The new constructor.

• The NEW associated constant,if both V and F implement core_extensions::ConstDefault (reexported in structural::reexports::ConstDefault).

Example

use structural::{StructuralExt, fp, ts};
use structural::for_examples::Variants;
use structural::path::VariantField;

let mut foo=Variants::Foo(3,5);

assert_eq!( foo.field_(fp!(::Foo.0)), Some(&3) );
assert_eq!( foo.field_(fp!(::Foo.1)), Some(&5) );
assert_eq!( foo.field_(fp!(::Boom.a)), None );
assert_eq!( foo.field_(fp!(::Boom.b)), None );
 
assert_eq!( foo.field_(VariantField::new(ts!(Foo), ts!(0))), Some(&3) );
assert_eq!( foo.field_(VariantField::new(ts!(Foo), ts!(1))), Some(&5) );
assert_eq!( foo.field_(VariantField::new(ts!(Boom), ts!(a))), None );
assert_eq!( foo.field_(VariantField::new(ts!(Boom), ts!(b))), None );


assert_eq!( foo.field_mut(fp!(::Foo.0)), Some(&mut 3) );
assert_eq!( foo.field_mut(fp!(::Foo.1)), Some(&mut 5) );
assert_eq!( foo.field_mut(fp!(::Boom.a)), None );
assert_eq!( foo.field_mut(fp!(::Boom.b)), None );
 
assert_eq!( foo.field_mut(VariantField::new(ts!(Foo), ts!(0))), Some(&mut 3) );
assert_eq!( foo.field_mut(VariantField::new(ts!(Foo), ts!(1))), Some(&mut 5) );
assert_eq!( foo.field_mut(VariantField::new(ts!(Boom), ts!(a))), None );
assert_eq!( foo.field_mut(VariantField::new(ts!(Boom), ts!(b))), None );

Fields

variant: V

The variant this accesses.

field: F

The field this accesses inside the variant.

Implementations

impl<V, F> VariantField<V, F>

where V: ConstDefault, F: ConstDefault,

pub const NEW: Self = ConstDefault::DEFAULT

Constructs a VariantField<V,F>

impl<V, F> VariantField<V, F>

pub const fn into_path(self) -> NestedFieldPath<(Self,)>

Constructs a NestedFieldPath from this.

pub const fn into_set(self) -> FieldPathSet<(Self,), UniquePaths>

Constructs a FieldPathSet from this.

impl<V, F> VariantField<V, F>

pub const fn new(variant: V, field: F) -> Self

Constructs a VariantField from the name of the variant,and field.

Both name and field is expected to be a ::structural::path::TStr.

Trait Implementations

impl<V: Clone, F: Clone> Clone for VariantField<V, F>

fn clone(&self) -> VariantField<V, F>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<V, F> ConstDefault for VariantField<V, F>

where V: ConstDefault, F: ConstDefault,

const DEFAULT: Self

The default value for Self.

impl<T, U> Debug for VariantField<T, U>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<V, F> IsMultiFieldPath for VariantField<V, F>

type PathUniqueness = UniquePaths

Whether the paths in the set can contain duplicate paths.

impl<V, F> Ord for VariantField<V, F>

fn cmp(&self, _other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<V, F> PartialEq for VariantField<V, F>

fn eq(&self, _other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<V, F> PartialOrd for VariantField<V, F>

fn partial_cmp(&self, _other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<This, _V, _F> RevFieldErr<This> for VariantField<_V, _F>

where This: ?Sized + FieldType<Self>,

type Err = FailedAccess

The error returned by rev_* methods.

impl<This, _V, _F> RevFieldType<This> for VariantField<_V, _F>

where This: ?Sized + FieldType<Self>,

type Ty = <This as FieldType<VariantField<_V, _F>>>::Ty

The type of the field.

impl<'a, This, _V, _F> RevGetFieldImpl<'a, This> for VariantField<_V, _F>

where This: ?Sized + 'a + GetVariantField<_V, _F>, This::Ty: 'a,

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

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

impl<'a, This, _V, _F> RevGetFieldMutImpl<'a, This> for VariantField<_V, _F>

where This: ?Sized + 'a + GetVariantFieldMut<_V, _F>, This::Ty: 'a,

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

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

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

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

impl<'a, This, V, F> RevGetMultiFieldImpl<'a, This> for VariantField<V, F>

where Self: RevGetFieldImpl<'a, This>, This: 'a + ?Sized, RGFT<Self, This>: 'a, Result<&'a RGFT<Self, This>, RGFE<Self, This>>: 'a + NormalizeFields,

type UnnormFields = (Result<&'a <VariantField<V, F> as RevFieldType<This>>::Ty, <VariantField<V, F> as RevFieldErr<This>>::Err>,)

A collection of Results<&'a _,_>s referencing fields.

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

Gets references to multiple fields from this.

impl<'a, This, V, F> RevGetMultiFieldMutImpl<'a, This> for VariantField<V, F>

where Self: RevGetFieldMutImpl<'a, This>, This: 'a + ?Sized, RGFT<Self, This>: 'a, Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, Result<*mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields,

type UnnormFieldsMut = (Result<&'a mut <VariantField<V, F> as RevFieldType<This>>::Ty, <VariantField<V, F> as RevFieldErr<This>>::Err>,)

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

type UnnormFieldsRawMut = (Result<*mut <VariantField<V, F> as RevFieldType<This>>::Ty, <VariantField<V, F> as RevFieldErr<This>>::Err>,)

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

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

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

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

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

impl<This, _V, _F> RevIntoFieldImpl<This> for VariantField<_V, _F>

where This: ?Sized + IntoVariantField<_V, _F>,

fn rev_into_field(self, this: This) -> Result<This::Ty, FailedAccess>

where This: Sized,

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

impl<This, V, F> RevIntoMultiFieldImpl<This> for VariantField<V, F>

where Self: RevIntoFieldImpl<This>, RGFT<Self, This>: Sized, Result<RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields,

type UnnormIntoFields = (Result<<VariantField<V, F> as RevFieldType<This>>::Ty, <VariantField<V, F> as RevFieldErr<This>>::Err>,)

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

fn rev_into_multi_field_impl( self, this: This, ) -> (Result<RGFT<Self, This>, RGFE<Self, This>>,)

Converts this into multiple fields by value, usually a tuple of Result<_, E: IsFieldErr>s.

impl<This, _V, _F> RevMoveOutFieldImpl<This> for VariantField<_V, _F>

where This: ?Sized + IntoVariantField<_V, _F>,

unsafe fn rev_move_out_field( self, this: &mut This, moved: &mut MovedOutFields, ) -> Result<This::Ty, FailedAccess>

where This::Ty: Sized,

Moves out the field that self represents inside of this.

impl<V: Copy, F: Copy> Copy for VariantField<V, F>

impl<V, F> Eq for VariantField<V, F>

impl<V, F> IsSingleFieldPath for VariantField<V, F>

impl<V, F> ShallowFieldPath for VariantField<V, F>