[−][src]Struct structural::enums::VariantProxy

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

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