Add the Enum trait to reflect enum types

Author: Davier

crates/bevy_reflect/src/enum_trait.rs

@@ -0,0 +1,53 @@
+use crate::{Reflect, Struct, Tuple};
+
+pub trait Enum: Reflect {
+    fn variant(&self) -> EnumVariant<'_>;
+    fn variant_mut(&mut self) -> EnumVariantMut<'_>;
+    fn variant_info(&self) -> VariantInfo<'_>;
+    fn iter_variants_info(&self) -> VariantInfoIter<'_>;
+    fn get_index_name(&self, index: usize) -> Option<&str>;
+    fn get_index_from_name(&self, name: &str) -> Option<usize>;
+}
+pub struct VariantInfo<'a> {
+    pub index: usize,
+    pub name: &'a str,
+}
+pub struct VariantInfoIter<'a> {
+    pub(crate) value: &'a dyn Enum,
+    pub(crate) index: usize,
+    pub(crate) len: usize,
+}
+impl<'a> Iterator for VariantInfoIter<'a> {
+    type Item = VariantInfo<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.index == self.len {
+            return None;
+        }
+        let item = VariantInfo {
+            index: self.index,
+            name: self.value.get_index_name(self.index).unwrap(),
+        };
+        self.index += 1;
+        Some(item)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let size = self.len - self.index;
+        (size, Some(size))
+    }
+}
+impl<'a> ExactSizeIterator for VariantInfoIter<'a> {}
+
+pub enum EnumVariant<'a> {
+    Unit,
+    NewType(&'a dyn Reflect),
+    Tuple(&'a dyn Tuple),
+    Struct(&'a dyn Struct),
+}
+pub enum EnumVariantMut<'a> {
+    Unit,
+    NewType(&'a mut dyn Reflect),
+    Tuple(&'a mut dyn Tuple),
+    Struct(&'a mut dyn Struct),
+}

crates/bevy_reflect/src/lib.rs

@@ -1,3 +1,4 @@
+mod enum_trait;
 mod list;
 mod map;
 mod path;
@@ -41,6 +42,7 @@ pub mod prelude {
     };
 }
 
+pub use enum_trait::*;
 pub use impls::*;
 pub use list::*;
 pub use map::*;

crates/bevy_reflect/src/reflect.rs

@@ -1,4 +1,4 @@
-use crate::{serde::Serializable, List, Map, Struct, Tuple, TupleStruct};
+use crate::{serde::Serializable, Enum, List, Map, Struct, Tuple, TupleStruct};
 use std::{any::Any, fmt::Debug};
 
 pub use bevy_utils::AHasher as ReflectHasher;
@@ -9,6 +9,7 @@ pub enum ReflectRef<'a> {
     Tuple(&'a dyn Tuple),
     List(&'a dyn List),
     Map(&'a dyn Map),
+    Enum(&'a dyn Enum),
     Value(&'a dyn Reflect),
 }
 
@@ -18,6 +19,7 @@ pub enum ReflectMut<'a> {
     Tuple(&'a mut dyn Tuple),
     List(&'a mut dyn List),
     Map(&'a mut dyn Map),
+    Enum(&'a mut dyn Enum),
     Value(&'a mut dyn Reflect),
 }
 

crates/bevy_reflect/src/serde/ser.rs

@@ -77,6 +77,9 @@ impl<'a> Serialize for ReflectSerializer<'a> {
                 value,
             }
             .serialize(serializer),
+            ReflectRef::Enum(_value) => {
+                todo!()
+            }
         }
     }
 }

examples/reflection/reflection_types.rs

@@ -75,6 +75,9 @@ fn setup() {
         // operations on your type, allowing you to interact with fields via their indices. Tuple is automatically
         // implemented for tuples of arity 12 or less.
         ReflectRef::Tuple(_) => {}
+        // `Enum` is a trait automatically implemented for enums that derive Reflect. This trait allows you
+        // to interact list possible variants and interact with the currently active one
+        ReflectRef::Enum(_) => {}
         // `List` is a special trait that can be manually implemented (instead of deriving Reflect). This exposes "list"
         // operations on your type, such as indexing and insertion. List is automatically implemented for relevant core
         // types like Vec<T>