Struct VariantProxy

pub struct VariantProxy<T: ?Sized, V> { /* private fields */ }

Enum wrapper,for accessing the fields of a particular variant (determined by the V type parameter).

The V type parameter is a TStr.

Example type: VariantProxy<Enum,TS!(Foo)>,Foo being the name of the variant.

Construction

These are 3 ways to construct a VariantProxy:

• Safe: Calling StructuralExt methods with fp!(::VariantName) as an argument, which returns an Option<VariantProxy<Self,TS!(VariantName)>> (reference methods return a reference to a VariantProxy).

• Safe: Calling an EnumExt method with fp!(VariantName) as an argument

• Unsafe: Calling a VariantProxy constructor function.

Generic parameters

T is the enum this wraps.

V is the name of the wrapped variant (example type:TS!(Bar)).

Example

This example constructs a VariantProxy safely.

use structural::{fp,ts,StructuralExt,Structural,TS};
use structural::enums::{EnumExt,VariantProxy};

with_bar(Foo::Bar(0,"hello"));

with_bar(Foo2::Bar(0,"hello",true));

/// Runs some assertions.
///
/// # Panics
///
/// This function panics if you pass an enum whose current variant is **not** `Bar`.
fn with_bar<T>(this: T)
where
    // `Foo_ESI` was generated by the `Structural` derive,
    // it aliases the accessor traits for `Foo`,
    // and also requires an enum with the same amount of variants as `Foo`
    //
    // `Debug` is required to print the enum in the `.expect(...)` error.
    T: Foo_ESI + Copy + std::fmt::Debug
{
    let mut proxy: VariantProxy<T, TS!(Bar)>=
        this.into_variant(ts!(Bar))
            .expect("Expected the `Bar` variant to be passed in");
    
    assert_eq!( proxy.field_(fp!(0)), &0);
    assert_eq!( proxy.field_(fp!(1)), &"hello");
    
    assert_eq!( proxy.field_mut(fp!(0)), &mut 0);
    assert_eq!( proxy.field_mut(fp!(1)), &mut "hello");
    
    assert_eq!( proxy.into_field(fp!(0)), 0);
    assert_eq!( proxy.into_field(fp!(1)), "hello");
}

#[derive(Debug,PartialEq,Structural,Copy,Clone)]
enum Foo{
    Bar(u32,&'static str),
    Baz(u32),
}

#[derive(Debug,PartialEq,Structural,Copy,Clone)]
enum Foo2{
    Bar(u32,&'static str,bool),
    Baz(u32,u64),
}

Example

This example uses an unsafe constructor.

use structural::{fp,ts,TS,StructuralExt,Structural};
use structural::enums::VariantProxy;


unsafe{
    with_bar(Foo::Bar(0,"hello"));

    with_bar(Foo2::Bar(0,"hello",true));
}

/// Runs some assertions.
///
/// # Safety
///
/// You must pass an enum whose current variant is `Bar`,
/// `this.is_variant(ts!(Bar))` (the method is from `StructuralExt`) must return true.
unsafe fn with_bar<T>(this: T)
where
    // `Foo_ESI` was generated by the `Structural` derive,
    // it aliases the accessor traits for `Foo`,
    // and also requires an enum with the same amount of variants as `Foo`
    T: Foo_ESI + Copy
{
    let mut proxy: VariantProxy<T, TS!(Bar)>=
        VariantProxy::new(this, ts!(Bar));
    
    assert_eq!( proxy.field_(fp!(0)), &0);
    assert_eq!( proxy.field_(fp!(1)), &"hello");
    
    assert_eq!( proxy.field_mut(fp!(0)), &mut 0);
    assert_eq!( proxy.field_mut(fp!(1)), &mut "hello");
    
    assert_eq!( proxy.into_field(fp!(0)), 0);
    assert_eq!( proxy.into_field(fp!(1)), "hello");
}

#[derive(Debug,PartialEq,Structural,Copy,Clone)]
enum Foo{
    Bar(u32,&'static str),
    Baz(u32),
}

#[derive(Debug,PartialEq,Structural,Copy,Clone)]
enum Foo2{
    Bar(u32,&'static str,bool),
    Baz(u32,u64),
}

Example

This example demonstrates how you can use a VariantProxy to treat a newtype variant as the struct that it wraps.

use structural::{StructuralExt, Structural, TS, fp};
use structural::enums::VariantProxy;

// `Point_SI` was generated by the `Structural` derive macro on `Point`,
// aliasing the accessor traits that `Point` implements.
fn with_bar(this: &impl Point_SI){
    assert_eq!( this.fields(fp!(x,y)), (&21, &34) );
}

let point=Point{x:21, y:34};
with_bar(&point);

let variant=Foo::Point(point);
// The type annotation here isn't necessary.
let proxy: &VariantProxy<Foo, TS!(Point)>=
    variant.field_(fp!(::Point)).expect("it was just constructed as a Foo::Point");
with_bar(proxy);


#[derive(Structural)]
// The `#[struc(no_trait)]` attribute disables the generation of
// the `*_SI` and `*_ESI` traits for this type.
#[struc(no_trait)]
pub enum Foo{
    // You would write this as `#[struc(newtype(bounds = "Point_VSI<@variant>"))]`
    // if you didn't use the  `#[struc(no_trait)]` attribute.
    #[struc(newtype)]
    Point(Point),
}

#[derive(Structural)]
pub struct Point{
    pub x:u32,
    pub y:u32,
}

Implementations

impl<T: ?Sized, V> VariantProxy<T, TStr<V>>

pub const unsafe fn new(value: T, name: TStr<V>) -> Self

where T: Sized,

Constructs this VariantProxy from an enum.

Safety

V must be the name of the wrapped enum variant.

Example

use structural::{fp,ts,TS,field_path_aliases,StructuralExt,Structural};
use structural::enums::VariantProxy;

#[derive(Debug,PartialEq,Structural)]
#[struc(no_trait)]
enum Foo{
    Bar(u32),
    Baz(u64),
}

let proxy: VariantProxy<Foo, TS!(Bar)>= unsafe{
    VariantProxy::new(Foo::Bar(0), ts!(Bar))
};

assert_eq!( proxy.into_field(fp!(0)), 0 );

pub unsafe fn from_ref(reference: &T, _: TStr<V>) -> &Self

Constructs this VariantProxy from a reference to an enum.

Safety

V must be the name of the wrapped enum variant.

Example

use structural::{fp,ts,TS,StructuralExt,Structural};
use structural::enums::VariantProxy;

#[derive(Debug,PartialEq,Structural)]
#[struc(no_trait)]
enum Foo{
    Bar(u32,bool),
    Baz(u32),
}

let proxy: &VariantProxy<Foo, TS!(Bar)>= unsafe{
    VariantProxy::from_ref(&Foo::Bar(99,false), ts!(Bar))
};

assert_eq!( proxy.field_(fp!(0)), &99 );
assert_eq!( proxy.field_(fp!(1)), &false );

pub unsafe fn from_mut(reference: &mut T, vari: TStr<V>) -> &mut Self

Constructs this VariantProxy from a mutable reference to the enum.

Safety

V must be the name of the wrapped enum variant.

Safety

V must be the name of the wrapped enum variant.

Example

use structural::{fp,ts,TS,StructuralExt,Structural};
use structural::enums::VariantProxy;

#[derive(Debug,PartialEq,Structural)]
#[struc(no_trait)]
enum Foo{
    Bar(u32),
    Baz(Option<usize>,Vec<String>),
}

let mut this=Foo::Baz(Some(1),vec![]);

let proxy: &mut VariantProxy<Foo, TS!(Baz)>= unsafe{
    VariantProxy::from_mut(&mut this, ts!(Baz))
};

assert_eq!( proxy.field_mut(fp!(0)), &mut Some(1) );
assert_eq!( proxy.field_mut(fp!(1)), &mut Vec::<String>::new() );

pub const unsafe fn from_raw_mut(ptr: *mut T, name: TStr<V>) -> *mut Self

Constructs this VariantProxy from a raw pointer to the enum.

Safety

V must be the name of the wrapped enum variant.

Safety

V must be the name of the wrapped enum variant.

Example

use structural::{fp,ts,TS,StructuralExt,Structural};
use structural::enums::VariantProxy;

use std::cmp::Ordering;

#[derive(Debug,PartialEq,Structural)]
#[struc(no_trait)]
enum Foo{
    Bar(u32),
    Baz(Ordering,&'static [u8]),
}

let mut this=Foo::Baz( Ordering::Less, &[0,1,2,3] );

let proxy: *mut VariantProxy<Foo, TS!(Baz)>= unsafe{
    VariantProxy::from_raw_mut(&mut this as *mut Foo, ts!(Baz))
};

unsafe{
    assert_eq!( (*proxy).field_mut(fp!(0)), &mut Ordering::Less );
    assert_eq!( (*proxy).field_mut(fp!(1)), &mut &[0,1,2,3] );
}

pub fn get(&self) -> &T

Gets a reference to the wrapped enum.

Example

use structural::{fp,ts,TS,StructuralExt,Structural};
use structural::enums::VariantProxy;

#[derive(Debug,PartialEq,Structural)]
#[struc(no_trait)]
enum Foo{
    Bar(u32),
    Baz(u32),
}

let proxy: VariantProxy<Foo, TS!(Bar)>= unsafe{
    VariantProxy::new(Foo::Bar(0), ts!(Bar))
};

assert_eq!(proxy.get() , &Foo::Bar(0));

pub unsafe fn get_mut(&mut self) -> &mut T

Gets a mutable reference to the wrapped enum.

Safety

You must not change the variant of the wrapped enum, since VariantProxy relies on it being the one that the V generic parmeter specifies

Example

use structural::{fp,ts,TS,StructuralExt,Structural};
use structural::enums::VariantProxy;

#[derive(Debug,PartialEq,Structural)]
#[struc(no_trait)]
enum Foo{
    Bar(u32),
    Baz(u32),
}

let mut this=Foo::Baz(0);

let proxy: &mut VariantProxy<Foo, TS!(Baz)>= unsafe{
    VariantProxy::from_mut(&mut this, ts!(Baz))
};

assert_eq!(unsafe{ proxy.get_mut() }, &mut Foo::Baz(0));

pub fn into_inner(self) -> T

where T: Sized,

Unwraps this VariantProxy into the enum it wraps.

Example

use structural::{fp,ts,TS,StructuralExt,Structural};
use structural::enums::VariantProxy;

#[derive(Debug,PartialEq,Structural)]
#[struc(no_trait)]
enum Foo{
    Bar(u32),
    Baz(u32),
}

let proxy: VariantProxy<Foo, TS!(Bar)>= unsafe{
    VariantProxy::new(Foo::Bar(0), ts!(Bar))
};

assert_eq!(proxy.into_inner() , Foo::Bar(0));

pub unsafe fn as_raw_mut(this: *mut Self) -> *mut T

Gets a mutable raw pointer to the wrapped enum.

Safety

You must not change the variant of the wrapped enum, because VariantProxy relies on it being the one that the V generic parmaetere specifies

Example

use structural::{fp,ts,TS,StructuralExt,Structural};
use structural::enums::VariantProxy;

#[derive(Debug,PartialEq,Structural)]
#[struc(no_trait)]
enum Foo{
    Bar(u32),
    Baz(u32),
}

let mut this=Foo::Baz(0);

let proxy: *mut VariantProxy<Foo, TS!(Baz)>= unsafe{
    VariantProxy::from_raw_mut(&mut this as *mut Foo, ts!(Baz))
};

assert_eq!(unsafe{  &mut *VariantProxy::as_raw_mut(proxy) }, &mut Foo::Baz(0));

Trait Implementations

impl<T: Clone + ?Sized, V: Clone> Clone for VariantProxy<T, V>

fn clone(&self) -> VariantProxy<T, V>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T, V> Debug for VariantProxy<T, V>

where T: ?Sized + Debug, V: IsTStr,

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

Formats the value using the given formatter.

impl<T: ?Sized, V> Deref for VariantProxy<T, V>

where V: IsTStr,

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T, V> DropFields for VariantProxy<T, V>

where T: IsVariant<V> + DropFields, V: IsTStr,

fn pre_move(&mut self)

What this type does right before any field is moved.

unsafe fn drop_fields(&mut self, moved: MovedOutFields)

Drops all the fields that were not moved out.

impl<T, V, F> FieldType<F> for VariantProxy<T, V>

where T: ?Sized + FieldType<VariantField<V, F>>, V: IsTStr,

type Ty = <T as FieldType<VariantField<V, F>>>::Ty

The type of the FieldPath field.

impl<T, V, F> GetField<F> for VariantProxy<T, V>

where T: ?Sized + GetVariantField<V, F>, V: IsTStr,

fn get_field_(&self, fname: F) -> &T::Ty

Accesses the FieldName field by reference.

impl<T, V, F> GetFieldMut<F> for VariantProxy<T, V>

where T: ?Sized + GetVariantFieldMut<V, F>, V: IsTStr,

fn get_field_mut_(&mut self, fname: F) -> &mut T::Ty

Accesses the FieldName field by mutable reference.

unsafe fn get_field_raw_mut(this: *mut (), fname: F) -> *mut T::Ty

where Self: Sized,

Gets a mutable pointer for the field.

fn get_field_raw_mut_fn(&self) -> GetFieldRawMutFn<F, T::Ty>

Gets the get_field_raw_mut associated function as a function pointer.

impl<T, V, F> IntoField<F> for VariantProxy<T, V>

where T: IntoVariantField<V, F>, V: IsTStr,

fn into_field_(self, fname: F) -> T::Ty

where Self: Sized,

Converts this into the field by value.

unsafe fn move_out_field_( &mut self, fname: F, moved: &mut MovedOutFields, ) -> T::Ty

where Self: Sized,

Moves out the field from self.

impl<T: Ord + ?Sized, V: Ord> Ord for VariantProxy<T, V>

fn cmp(&self, other: &VariantProxy<T, V>) -> 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 + ?Sized, V: PartialEq> PartialEq for VariantProxy<T, V>

fn eq(&self, other: &VariantProxy<T, V>) -> 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 + ?Sized, V: PartialOrd> PartialOrd for VariantProxy<T, V>

fn partial_cmp(&self, other: &VariantProxy<T, V>) -> 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<T: Copy + ?Sized, V: Copy> Copy for VariantProxy<T, V>

impl<T: Eq + ?Sized, V: Eq> Eq for VariantProxy<T, V>

impl<T: ?Sized, V> StructuralPartialEq for VariantProxy<T, V>