Struct VariantName

pub struct VariantName<V> {
    pub name: V,
}

This allows accessing the V enum variant (by constructing a VariantProxy representing that variant).

This is the type that fp!(::Foo) constructs.
Note that fp!(::Foo.bar) constructs a VariantField instead.

The V type parameters is a TStr.

Construction

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

• fp macro,with fp!(::Foo)

• The VariantName{name} struct literal

• The new constructor.

• The NEW associated constant,if V implements core_extensions::ConstDefault (reexported in structural::reexports::ConstDefault)

Example

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

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

{
    let proxy= foo.field_(fp!(::Foo)).unwrap();
    assert_eq!( proxy.field_(fp!(0)), &3 );
    assert_eq!( proxy.field_(fp!(1)), &5 );
}
assert_eq!( foo.field_(fp!(::Boom)), None );
 
{
    let proxy= foo.field_(VariantName::new(ts!(Foo))).unwrap();
    assert_eq!( proxy.field_(fp!(0)), &3 );
    assert_eq!( proxy.field_(fp!(1)), &5 );
}
assert_eq!( foo.field_(VariantName::new(ts!(Boom))), None );
 
 
{
    let proxy= foo.field_mut(fp!(::Foo)).unwrap();
    assert_eq!( proxy.field_mut(fp!(0)), &mut 3 );
    assert_eq!( proxy.field_mut(fp!(1)), &mut 5 );
}
assert_eq!( foo.field_mut(fp!(::Boom)), None );
 
{
    let proxy= foo.field_mut(VariantName::new(ts!(Foo))).unwrap();
    assert_eq!( proxy.field_mut(fp!(0)), &mut 3 );
    assert_eq!( proxy.field_mut(fp!(1)), &mut 5 );
}
assert_eq!( foo.field_mut(VariantName::new(ts!(Boom))), None );
 
 

Fields

name: V

The variant this accesses.

Implementations

impl<V> VariantName<V>

where V: ConstDefault,

pub const NEW: Self = Self::DEFAULT

Constructs a VariantName.

impl<V> VariantName<V>

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> VariantName<V>

pub fn new(name: V) -> Self

Constructs a VariantName from name.

name is expected to be a ::structural::path::TStr.

Trait Implementations

impl<V: Clone> Clone for VariantName<V>

fn clone(&self) -> VariantName<V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<V> ConstDefault for VariantName<V>

where V: ConstDefault,

const DEFAULT: Self

The default value for Self.

impl<T> Debug for VariantName<T>

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

Formats the value using the given formatter.

impl<V: Default> Default for VariantName<V>

fn default() -> VariantName<V>

Returns the “default value” for a type.

impl<T> IsMultiFieldPath for VariantName<T>

type PathUniqueness = UniquePaths

Whether the paths in the set can contain duplicate paths.

impl<T> Ord for VariantName<T>

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<T> PartialEq for VariantName<T>

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<T> PartialOrd for VariantName<T>

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, S> RevFieldErr<This> for VariantName<TStr<S>>

where This: ?Sized + IsVariant<TStr<S>>, S: 'static,

type Err = FailedAccess

The error returned by rev_* methods.

impl<This, S> RevFieldType<This> for VariantName<TStr<S>>

where This: ?Sized + IsVariant<TStr<S>>, S: 'static,

type Ty = VariantProxy<This, TStr<S>>

The type of the field.

impl<'a, This, S> RevGetFieldImpl<'a, This> for VariantName<TStr<S>>

where This: ?Sized + 'a + IsVariant<TStr<S>>, S: 'static,

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

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

impl<'a, This, S> RevGetFieldMutImpl<'a, This> for VariantName<TStr<S>>

where This: ?Sized + 'a + IsVariant<TStr<S>>, S: 'static,

fn rev_get_field_mut( self, this: &'a mut This, ) -> Result<&'a mut VariantProxy<This, TStr<S>>, 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 VariantProxy<This, TStr<S>>, FailedAccess>

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

impl<'a, This, T> RevGetMultiFieldImpl<'a, This> for VariantName<T>

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 <VariantName<T> as RevFieldType<This>>::Ty, <VariantName<T> 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, T> RevGetMultiFieldMutImpl<'a, This> for VariantName<T>

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 <VariantName<T> as RevFieldType<This>>::Ty, <VariantName<T> as RevFieldErr<This>>::Err>,)

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

type UnnormFieldsRawMut = (Result<*mut <VariantName<T> as RevFieldType<This>>::Ty, <VariantName<T> 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, S> RevIntoFieldImpl<This> for VariantName<TStr<S>>

where This: ?Sized + IsVariant<TStr<S>>, S: 'static,

fn rev_into_field( self, this: This, ) -> Result<VariantProxy<This, TStr<S>>, FailedAccess>

where This: Sized,

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

impl<This, T> RevIntoMultiFieldImpl<This> for VariantName<T>

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

type UnnormIntoFields = (Result<<VariantName<T> as RevFieldType<This>>::Ty, <VariantName<T> 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<V: Copy> Copy for VariantName<V>

impl<T> Eq for VariantName<T>

impl<V> IsSingleFieldPath for VariantName<V>