Trait structural::enums::IsVariant

pub unsafe trait IsVariant<V>: AssertTStrParam<V> {
    fn is_variant_(&self, variant: V) -> bool;
}

Queries whether an enum is some variant (the V type parameter)

Example bounds: IsVariant<TS!(Foo)>,IsVariant<TS!(Bar)>.

Safety

An implementation of IsVariant<TS!(Foo)> must only return true if the enum is the Foo variant (Foo is just an example,it applies to all variants).

Undefined behavior will happen if this trait return true, while the accessor for a field of that variant returns None.

Example

use structural::enums::IsVariant;
use structural::{TS,Structural,fp};

assertions(Enum::Foo, Enum::Bar(0), Enum::Boom{x:0,y:false});

assertions(Enum2::Foo, Enum2::Bar, Enum2::Boom);

fn assertions<T>(foo:T, bar:T, boom:T)
where
    T: IsVariant<TS!(Foo)> + IsVariant<TS!(Bar)> + IsVariant<TS!(Boom)>
{
    assert_eq!( foo.is_variant_(fp!(Foo)), true );
    assert_eq!( foo.is_variant_(fp!(Bar)), false );
    assert_eq!( foo.is_variant_(fp!(Boom)), false );
    
    assert_eq!( bar.is_variant_(fp!(Foo)), false );
    assert_eq!( bar.is_variant_(fp!(Bar)), true );
    assert_eq!( bar.is_variant_(fp!(Boom)), false );
    
    assert_eq!( boom.is_variant_(fp!(Foo)), false );
    assert_eq!( boom.is_variant_(fp!(Bar)), false );
    assert_eq!( boom.is_variant_(fp!(Boom)), true );
}

#[derive(Structural)]
enum Enum{
    Foo,
    Bar(u8),
    Boom{x:u32,y:bool},
}

#[derive(Structural)]
enum Enum2{
    Foo,
    Bar,
    Boom,
}

Required methods

fn is_variant_(&self, variant: V) -> bool

Checks whether this enum is the variant that V stands for.

Loading content...

Implementations on Foreign Types

impl<T> IsVariant<TStr<__TS<(__S, __o, __m, __e)>>> for Option<T>

fn is_variant_(&self, _: TStr<__TS<(__S, __o, __m, __e)>>) -> bool

impl<T> IsVariant<TStr<__TS<(__N, __o, __n, __e)>>> for Option<T>

fn is_variant_(&self, _: TStr<__TS<(__N, __o, __n, __e)>>) -> bool

impl<T, E> IsVariant<TStr<__TS<(__O, __k)>>> for Result<T, E>

fn is_variant_(&self, _: TStr<__TS<(__O, __k)>>) -> bool

impl<T, E> IsVariant<TStr<__TS<(__E, __r, __r)>>> for Result<T, E>

fn is_variant_(&self, _: TStr<__TS<(__E, __r, __r)>>) -> bool

impl<T, __V> IsVariant<TStr<__V>> for ManuallyDrop<T> where
    T: IsVariant<TStr<__V>>, 

fn is_variant_(&self, name: TStr<__V>) -> bool

impl<P, __V> IsVariant<TStr<__V>> for Pin<P> where
    P::Target: IsVariant<TStr<__V>>,
    P: Deref,
    P::Target: Sized, 

fn is_variant_(&self, name: TStr<__V>) -> bool

impl<T, __V> IsVariant<TStr<__V>> for Arc<T> where
    T: IsVariant<TStr<__V>>,
    T: ?Sized, 

fn is_variant_(&self, name: TStr<__V>) -> bool

impl<T, __V> IsVariant<TStr<__V>> for Rc<T> where
    T: IsVariant<TStr<__V>>,
    T: ?Sized, 

fn is_variant_(&self, name: TStr<__V>) -> bool

impl<T, __V> IsVariant<TStr<__V>> for Box<T> where
    T: IsVariant<TStr<__V>>,
    T: ?Sized, 

fn is_variant_(&self, name: TStr<__V>) -> bool

impl<'a, T, __V> IsVariant<TStr<__V>> for &'a T where
    T: IsVariant<TStr<__V>>,
    T: ?Sized, 

fn is_variant_(&self, name: TStr<__V>) -> bool

impl<'a, T, __V> IsVariant<TStr<__V>> for &'a mut T where
    T: IsVariant<TStr<__V>>,
    T: 'a + ?Sized, 

fn is_variant_(&self, name: TStr<__V>) -> bool

Loading content...

Implementors

impl<T, __V> IsVariant<TStr<__V>> for FieldCloner<T> where
    T: IsVariant<TStr<__V>>, 

fn is_variant_(&self, name: TStr<__V>) -> bool

impl<T, __V> IsVariant<TStr<__V>> for StrucWrapper<T> where
    T: IsVariant<TStr<__V>>, 

fn is_variant_(&self, name: TStr<__V>) -> bool

Loading content...