Struct bevy::reflect::TupleStructInfo

pub struct TupleStructInfo { /* private fields */ }
Expand description

A container for compile-time tuple struct info.

Implementations§

§

impl TupleStructInfo

pub fn new<T>(fields: &[UnnamedField]) -> TupleStructInfo
where T: Reflect + TypePath,

Create a new TupleStructInfo.

§Arguments
  • fields: The fields of this struct in the order they are defined

pub fn with_custom_attributes( self, custom_attributes: CustomAttributes, ) -> TupleStructInfo

Sets the custom attributes for this struct.

pub fn field_at(&self, index: usize) -> Option<&UnnamedField>

Get the field at the given index.

pub fn iter(&self) -> Iter<'_, UnnamedField>

Iterate over the fields of this struct.

pub fn field_len(&self) -> usize

The total number of fields in this struct.

pub fn type_path_table(&self) -> &TypePathTable

A representation of the type path of the struct.

Provides dynamic access to all methods on TypePath.

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

The stable, full type path of the struct.

Use type_path_table if you need access to the other methods on TypePath.

pub fn type_id(&self) -> TypeId

The TypeId of the tuple struct.

pub fn is<T>(&self) -> bool
where T: Any,

Check if the given type matches the tuple struct type.

pub fn custom_attributes(&self) -> &CustomAttributes

Returns the custom attributes for this item.

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.

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.

Examples found in repository?
examples/reflection/custom_attributes.rs (line 62)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
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 has_attribute<T>(&self) -> bool
where T: Reflect,

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

For dynamically checking if an attribute exists, see has_attribute_by_id.

Examples found in repository?
examples/reflection/custom_attributes.rs (line 57)
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
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 has_attribute_by_id(&self, id: TypeId) -> bool

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

This is the dynamic equivalent of has_attribute

Trait Implementations§

§

impl Clone for TupleStructInfo

§

fn clone(&self) -> TupleStructInfo

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
§

impl Debug for TupleStructInfo

§

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

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

source§

impl<T> Any for T
where T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
§

impl<T, U> AsBindGroupShaderType<U> for T
where U: ShaderType, &'a T: for<'a> Into<U>,

§

fn as_bind_group_shader_type(&self, _images: &RenderAssets<GpuImage>) -> U

Return the T ShaderType for self. When used in AsBindGroup derives, it is safe to assume that all images in self exist.
source§

impl<T> Borrow<T> for T
where T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
§

impl<T> Downcast<T> for T

§

fn downcast(&self) -> &T

§

impl<T> Downcast for T
where T: Any,

§

fn into_any(self: Box<T>) -> Box<dyn Any>

Convert Box<dyn Trait> (where Trait: Downcast) to Box<dyn Any>. Box<dyn Any> can then be further downcast into Box<ConcreteType> where ConcreteType implements Trait.
§

fn into_any_rc(self: Rc<T>) -> Rc<dyn Any>

Convert Rc<Trait> (where Trait: Downcast) to Rc<Any>. Rc<Any> can then be further downcast into Rc<ConcreteType> where ConcreteType implements Trait.
§

fn as_any(&self) -> &(dyn Any + 'static)

Convert &Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &Any’s vtable from &Trait’s.
§

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Convert &mut Trait (where Trait: Downcast) to &Any. This is needed since Rust cannot generate &mut Any’s vtable from &mut Trait’s.
§

impl<T> DowncastSync for T
where T: Any + Send + Sync,

§

fn into_any_arc(self: Arc<T>) -> Arc<dyn Any + Sync + Send>

Convert Arc<Trait> (where Trait: Downcast) to Arc<Any>. Arc<Any> can then be further downcast into Arc<ConcreteType> where ConcreteType implements Trait.
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<S> FromSample<S> for S

§

fn from_sample_(s: S) -> S

§

impl<T> Instrument for T

§

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more
§

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more
source§

impl<T, U> Into<U> for T
where U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> IntoEither for T

source§

fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts self into a Left variant of Either<Self, Self> if into_left is true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
source§

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts self into a Left variant of Either<Self, Self> if into_left(&self) returns true. Converts self into a Right variant of Either<Self, Self> otherwise. Read more
§

impl<F, T> IntoSample<T> for F
where T: FromSample<F>,

§

fn into_sample(self) -> T

§

impl<T> Pointable for T

§

const ALIGN: usize = _

The alignment of pointer.
§

type Init = T

The type for initializers.
§

unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
§

unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
§

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
§

unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
source§

impl<T> Same for T

§

type Output = T

Should always be Self
source§

impl<T> ToOwned for T
where T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

impl<T, U> ToSample<U> for T
where U: FromSample<T>,

§

fn to_sample_(self) -> U

source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
§

impl<T> TypeData for T
where T: 'static + Send + Sync + Clone,

§

fn clone_type_data(&self) -> Box<dyn TypeData>

§

impl<T> Upcast<T> for T

§

fn upcast(&self) -> Option<&T>

§

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

§

fn vzip(self) -> V

§

impl<T> WithSubscriber for T

§

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more
§

fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default Subscriber to this type, returning a WithDispatch wrapper. Read more
§

impl<T> ConditionalSend for T
where T: Send,

§

impl<S, T> Duplex<S> for T
where T: FromSample<S> + ToSample<S>,

§

impl<T> Settings for T
where T: 'static + Send + Sync,

§

impl<T> WasmNotSend for T
where T: Send,

§

impl<T> WasmNotSendSync for T
where T: WasmNotSend + WasmNotSync,

§

impl<T> WasmNotSync for T
where T: Sync,