Struct enumeration::VariantWith

pub struct VariantWith<T: Debug, U: 'static> { /* private fields */ }

Provides runtime specialized representation of Enumeration with specified Enumeration::AssociatedValueType. More details in Variant.

It’s basically Variant but with specified on what it’s Enumeration::AssociatedValueType must be.

Examples

enumerate!(Foo(u8; i32)
    Bar = 111
    Baz = 333
);
 
enumerate!(Color(u8; &'static str)
    Red = "#FF0000"
    Blue = "#0000FF"
    Yellow = "#FFFF00"
    Cyan = "#00FFFF"
);
 
let mut vec = vec![Color::Red.into(), Color::Blue.into()];
 
assert_eq!(vec[0].value(), "#FF0000");
 
vec.push(Foo::Bar.into()); // compile error

Implementations

impl<T: Debug, U: 'static> VariantWith<T, U>

pub fn new<E: Enumeration>( e: E ) -> VariantWith<E::Index, E::AssociatedValueType>

Constructs VariantWith with Enumeration

pub fn type_id(self) -> TypeId

Returns the type id.

pub fn index(self) -> T

Returns the index.

pub fn value(self) -> &'static U

Returns the associated constant value without casting.

pub fn cast<E: Enumeration<Index = T, AssociatedValueType = U>>( self ) -> Result<E, CastError<E>>

Try casting to the given generic parameter

Trait Implementations

impl<T: Clone + Debug, U: Clone + 'static> Clone for VariantWith<T, U>

fn clone(&self) -> VariantWith<T, U>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Debug, U: Debug + 'static> Debug for VariantWith<T, U>

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

Formats the value using the given formatter.

impl<T: Enumeration> From<T> for VariantWith<T::Index, T::AssociatedValueType>

fn from(e: T) -> Self

Converts to this type from the input type.

impl<T: Hash + Debug, U: Hash + 'static> Hash for VariantWith<T, U>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Ord + Debug, U: Ord + 'static> Ord for VariantWith<T, U>

fn cmp(&self, other: &VariantWith<T, U>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<T: PartialEq + Debug, U: PartialEq + 'static> PartialEq<VariantWith<T, U>> for VariantWith<T, U>

fn eq(&self, other: &VariantWith<T, U>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: PartialOrd + Debug, U: PartialOrd + 'static> PartialOrd<VariantWith<T, U>> for VariantWith<T, U>

fn partial_cmp(&self, other: &VariantWith<T, U>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

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<T: Copy + Debug, U: Copy + 'static> Copy for VariantWith<T, U>

impl<T: Eq + Debug, U: Eq + 'static> Eq for VariantWith<T, U>

impl<T: Debug, U: 'static> StructuralEq for VariantWith<T, U>

impl<T: Debug, U: 'static> StructuralPartialEq for VariantWith<T, U>