Struct structural::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

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<V: Copy, F: Copy> Copy for VariantField<V, F>

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> Eq for VariantField<V, F>

impl<T, E> FieldType<VariantField<TStr<__TS<(__E, __r, __r)>>, TStr<__TS<(__0,)>>>> for Result<T, E>

type Ty = E

The type of the FieldPath field.

impl<T, E> FieldType<VariantField<TStr<__TS<(__O, __k)>>, TStr<__TS<(__0,)>>>> for Result<T, E>

type Ty = T

The type of the FieldPath field.

impl<T> FieldType<VariantField<TStr<__TS<(__S, __o, __m, __e)>>, TStr<__TS<(__0,)>>>> for Option<T>

type Ty = T

The type of the FieldPath field.

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

type PathUniqueness = UniquePaths

Whether the paths in the set can contain duplicate paths.

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

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

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

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

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

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<V, F> PartialOrd<VariantField<V, F>> 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.

#[must_use]fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

#[must_use]fn ge(&self, other: &Rhs) -> bool

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

impl<This: ?Sized, _V, _F> RevFieldErr<This> for VariantField<_V, _F> where
    This: FieldType<Self>, 

type Err = FailedAccess

The error returned by rev_* methods.

impl<This: ?Sized, _V, _F> RevFieldType<This> for VariantField<_V, _F> where
    This: FieldType<Self>, 

type Ty = GetFieldType<This, Self>

The type of the field.

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>

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

impl<'a, This: ?Sized, _V, _F> RevGetFieldMutImpl<'a, This> for VariantField<_V, _F> where
    This: '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: ?Sized, V, F> RevGetMultiFieldImpl<'a, This> for VariantField<V, F> where
    Self: RevGetFieldImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a RGFT<Self, This>, RGFE<Self, This>>: 'a + NormalizeFields, 

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

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: ?Sized, V, F> RevGetMultiFieldMutImpl<'a, This> for VariantField<V, F> where
    Self: RevGetFieldMutImpl<'a, This>,
    This: 'a,
    RGFT<Self, This>: 'a,
    Result<&'a mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields,
    Result<*mut RGFT<Self, This>, RGFE<Self, This>>: NormalizeFields, 

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

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

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

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: ?Sized, _V, _F> RevIntoFieldImpl<This> for VariantField<_V, _F> where
    This: 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<RGFT<Self, This>, RGFE<Self, This>>,)

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: ?Sized, _V, _F> RevMoveOutFieldImpl<This> for VariantField<_V, _F> where
    This: 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, F> ShallowFieldPath for VariantField<V, F>