Enum lain::types::UnsafeEnum

pub enum UnsafeEnum<T, I> {
    Valid(T),
    Invalid(I),
}

Represents an enum that can contain unsafe values.

These are enums which may potentially be used as indices, offsets, or used in some other calculation. This wrapper type exists since the Rust compiler makes strong assumptions about how enums are used, and if you attempt to unsafely (either through a union or pointers) set the value of an enum to an indiscriminant value, you will regularly hit issues with illegal instructions being executed while in debug mode. See, Rust will emit certain LLVM IR code like unreachable; to give LLVM certain hints. The problem is that Rust believes (and rightfully so) that enums have discrete values unless they are programmed to contain custom discriminant values. So if you have ane num like:

enum MyEnum {
    Foo = 1,
    Bar,
    Baz, // ...
}

Rust expects in some scenarios that all possible values have been accounted for so the following is emitted:

let my_enum_instance = MyEnum::Foo;
match my_enum_instance {
    MyEnum::Foo | MyEnum::Bar | MyEnum::Baz => println!("All possibilities accounted for :)"), // your code
    _ => unreachable(), // the compiler will insert this branch in some scenarios
}

But what if you set the value of your instance to something other than 1, 2, or 3 via unsafe code? That unreachable() block is hit in debug builds only and suddenly your code doesn’t work. In release mode, sometimes the _ (default) path is actually used to hold the first item of the enum, so your “all other values” code path actually represents a very real value.

TL;DR Rust makes too many assumptions about how enums are used to make doing unsafe things with them worthwhile. This wrapper enum works around that.

Variants

Valid(T)

Invalid(I)

Trait Implementations

impl<T, I> BinarySerialize for UnsafeEnum<T, I> where
    T: BinarySerialize,
    I: BinarySerialize + Clone, 

default fn binary_serialize<W: Write, E: ByteOrder>(
    &self,
    buffer: &mut W
) -> usize

Pushes all fields in self to a buffer

impl<T: Clone, I: Clone> Clone for UnsafeEnum<T, I>

fn clone(&self) -> UnsafeEnum<T, I>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, I: Debug> Debug for UnsafeEnum<T, I>

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

Formats the value using the given formatter.

impl<T, I> Default for UnsafeEnum<T, I> where
    T: Default, 

fn default() -> Self

Returns the “default value” for a type.

impl<T, I> Mutatable for UnsafeEnum<T, I> where
    T: ToPrimitive<Output = I>,
    I: BitXor<Output = I> + NumCast + Bounded + Copy + Debug + Default + DangerousNumber<I> + Display + WrappingAdd + WrappingSub, 

type RangeType = I

fn mutate<R: Rng>(
    &mut self,
    mutator: &mut Mutator<R>,
    _constraints: Option<&Constraints<Self::RangeType>>
)

impl<T, I> NewFuzzed for UnsafeEnum<T, I> where
    T: NewFuzzed,
    I: NewFuzzed<RangeType = I> + Bounded + Debug + Default, 

type RangeType = I

fn new_fuzzed<R: Rng>(
    mutator: &mut Mutator<R>,
    constraints: Option<&Constraints<Self::RangeType>>
) -> Self

Picks a random variant of Self

impl<E, T> ToPrimitive for UnsafeEnum<E, T> where
    E: ToPrimitive<Output = T>,
    T: Copy, 

type Output = T

fn to_primitive(&self) -> T

impl<T: Copy, I: Copy> Copy for UnsafeEnum<T, I>