Struct EnumType 

pub struct EnumType { /* private fields */ }

An enum type is a special type that takes one of two forms:

1. C-like enumeration of named integer values, where the discriminant is the integral type
2. Rust-like enumeration over the variant types, tagged with a value of the discriminant type

In 1, the variants are all of the same type as the discriminant. In 2, the variants may each be different shape.

Implementations

impl EnumType

pub fn new<I>( name: Arc<str>, discriminant: Type, variants: I, ) -> Result<EnumType, InvalidEnumTypeError>

where I: IntoIterator<Item = Variant>,

Construct a new EnumType with the given name, discriminant type, and variants.

pub fn phantom( name: Arc<str>, discriminant: Type, ) -> Result<EnumType, InvalidEnumTypeError>

Construct a new EnumType representing a phantom type with the given name and discriminant

pub fn name(&self) -> &Arc<str>

Returns the name of this enum type

pub fn discriminant(&self) -> &Type

Returns the discriminant type for this enum

pub fn variants(&self) -> &[Variant]

Returns the variants of this enum

pub fn variant_offsets(&self) -> impl ExactSizeIterator

Returns an iterator over the variants of this enumeration with their offset from the base of the enum (i.e. given a pointer to a value of this type, the offset can be used to derive a pointer to the variant value type).

pub fn discriminant_values(&self) -> impl ExactSizeIterator

Returns an iterator over the discriminant values of this enum.

The order of values produced by this iterator is identical to the order of the variants.

Discriminant values are computed as follows:

• Variants either have an explicit discriminant value set, or receive a discriminant value derived from the preceding variant by adding 1 to it.
• If the first variant has no explicit value, the discriminant value range begins at 0.
• If the the end of the valid discriminant value range is reached before the last variant, this function will panic with an assertion pointing to the invalid variant.

pub fn is_phantom(&self) -> bool

Returns true if this type has no variants, and thus no physical in-memory representation.

pub fn is_zst(&self) -> bool

Returns true if this type has no physical in-memory representation, i.e. it is a phantom

pub fn is_c_like(&self) -> bool

Returns true if this enum type is a C-like enum, i.e. where the type is equivalent to the discriminant value type.

pub fn size_in_bytes(&self) -> usize

Returns the size in bytes of this type, without alignment padding.

pub fn size_in_bits(&self) -> usize

Returns the size in bits of this type, without alignment padding.

pub fn min_alignment(&self) -> usize

Returns the minimum alignment, in bytes, of this type

Trait Implementations

impl Clone for EnumType

fn clone(&self) -> EnumType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EnumType

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EnumType

fn deserialize<__D>( __deserializer: __D, ) -> Result<EnumType, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for EnumType

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

Print this type for display using the provided module context

impl Eq for EnumType

impl Hash for EnumType

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

where __H: Hasher,

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 PartialEq for EnumType

fn eq(&self, other: &EnumType) -> 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 PrettyPrint for EnumType

fn render(&self) -> Document

The core of the PrettyPrint functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.

impl Serialize for EnumType

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EnumType