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

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<V: Copy> Copy for VariantName<V>

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

impl<T> IsMultiFieldPath for VariantName<T>

type PathUniqueness = UniquePaths

Whether the paths in the set can contain duplicate paths.

impl<V> IsSingleFieldPath for VariantName<V>

impl<T> Ord for VariantName<T>

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

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

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, S> RevFieldErr<This> for VariantName<TStr<S>> where
    This: IsVariant<TStr<S>>,
    S: 'static, 

type Err = FailedAccess

The error returned by rev_* methods.

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

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

The type of the field.

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>

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

impl<'a, This: ?Sized, S> RevGetFieldMutImpl<'a, This> for VariantName<TStr<S>> where
    This: '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: ?Sized, T> RevGetMultiFieldImpl<'a, This> for VariantName<T> 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, T> RevGetMultiFieldMutImpl<'a, This> for VariantName<T> 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, S> RevIntoFieldImpl<This> for VariantName<TStr<S>> where
    This: 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<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.