Enum VariantInfo 

pub enum VariantInfo {
    Struct(StructVariantInfo),
    Tuple(TupleVariantInfo),
    Unit(UnitVariantInfo),
}

A container for compile-time enum variant info.

Variants

Struct(StructVariantInfo)

Struct enums take the form:

enum MyEnum {
  A {
    foo: usize
  }
}

Tuple(TupleVariantInfo)

Tuple enums take the form:

enum MyEnum {
  A(usize)
}

Unit(UnitVariantInfo)

Unit enums take the form:

enum MyEnum {
  A
}

Implementations

impl VariantInfo

pub fn name(&self) -> &'static str

The name of the enum variant.

pub fn docs(&self) -> Option<&str>

Available on crate feature documentation only.

The docstring of the underlying variant, if any.

pub fn variant_type(&self) -> VariantType

Returns the type of this variant.

pub fn custom_attributes(&self) -> &CustomAttributes

Returns the custom attributes for this variant.

pub fn get_attribute<T>(&self) -> Option<&T>

where T: Reflect,

Gets a custom attribute by type.

For dynamically accessing an attribute, see get_attribute_by_id.

Examples found in repository

examples/reflection/custom_attributes.rs (line 85)

fn main() {
    // Bevy supports statically registering custom attribute data on reflected types,
    // which can then be accessed at runtime via the type's `TypeInfo`.
    // Attributes are registered using the `#[reflect(@...)]` syntax,
    // where the `...` is any expression that resolves to a value which implements `Reflect`.
    // Note that these attributes are stored based on their type:
    // if two attributes have the same type, the second one will overwrite the first.

    // Here is an example of registering custom attributes on a type:
    #[derive(Reflect)]
    struct Slider {
        #[reflect(@RangeInclusive::<f32>::new(0.0, 1.0))]
        // Alternatively, we could have used the `0.0..=1.0` syntax,
        // but remember to ensure the type is the one you want!
        #[reflect(@0.0..=1.0_f32)]
        value: f32,
    }

    // Now, we can access the custom attributes at runtime:
    let TypeInfo::Struct(type_info) = Slider::type_info() else {
        panic!("expected struct");
    };

    let field = type_info.field("value").unwrap();

    let range = field.get_attribute::<RangeInclusive<f32>>().unwrap();
    assert_eq!(*range, 0.0..=1.0);

    // And remember that our attributes can be any type that implements `Reflect`:
    #[derive(Reflect)]
    struct Required;

    #[derive(Reflect, PartialEq, Debug)]
    struct Tooltip(String);

    impl Tooltip {
        fn new(text: &str) -> Self {
            Self(text.to_string())
        }
    }

    #[derive(Reflect)]
    #[reflect(@Required, @Tooltip::new("An ID is required!"))]
    struct Id(u8);

    let TypeInfo::TupleStruct(type_info) = Id::type_info() else {
        panic!("expected struct");
    };

    // We can check if an attribute simply exists on our type:
    assert!(type_info.has_attribute::<Required>());

    // We can also get attribute data dynamically:
    let some_type_id = TypeId::of::<Tooltip>();

    let tooltip: &dyn Reflect = type_info.get_attribute_by_id(some_type_id).unwrap();
    assert_eq!(
        tooltip.downcast_ref::<Tooltip>(),
        Some(&Tooltip::new("An ID is required!"))
    );

    // And again, attributes of the same type will overwrite each other:
    #[derive(Reflect)]
    enum Status {
        // This will result in `false` being stored:
        #[reflect(@true)]
        #[reflect(@false)]
        Disabled,
        // This will result in `true` being stored:
        #[reflect(@false)]
        #[reflect(@true)]
        Enabled,
    }

    let TypeInfo::Enum(type_info) = Status::type_info() else {
        panic!("expected enum");
    };

    let disabled = type_info.variant("Disabled").unwrap();
    assert!(!disabled.get_attribute::<bool>().unwrap());

    let enabled = type_info.variant("Enabled").unwrap();
    assert!(enabled.get_attribute::<bool>().unwrap());
}

pub fn get_attribute_by_id( &self, id: TypeId, ) -> Option<&(dyn Reflect + 'static)>

Gets a custom attribute by its TypeId.

This is the dynamic equivalent of get_attribute.

pub fn has_attribute<T>(&self) -> bool

where T: Reflect,

Returns true if this variant has a custom attribute of the specified type.

For dynamically checking if an attribute exists, see has_attribute_by_id.

pub fn has_attribute_by_id(&self, id: TypeId) -> bool

Returns true if this variant has a custom attribute with the specified TypeId.

This is the dynamic equivalent of has_attribute

impl VariantInfo

Conversion convenience methods for VariantInfo.

pub fn as_struct_variant(&self) -> Result<&StructVariantInfo, VariantInfoError>

Attempts a cast to StructVariantInfo.

Returns an error if self is not VariantInfo::Struct.

pub fn as_tuple_variant(&self) -> Result<&TupleVariantInfo, VariantInfoError>

Attempts a cast to TupleVariantInfo.

Returns an error if self is not VariantInfo::Tuple.

pub fn as_unit_variant(&self) -> Result<&UnitVariantInfo, VariantInfoError>

Attempts a cast to UnitVariantInfo.

Returns an error if self is not VariantInfo::Unit.

Trait Implementations

impl Clone for VariantInfo

fn clone(&self) -> VariantInfo

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for VariantInfo

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

Formats the value using the given formatter.