Adding SelectView/SelectViewMut/SelectBorrow and adding support for them in World view/view_mut/borrow functions

Author: recatek

CHANGELOG

@@ -1,6 +1,4 @@
 ## [Unreleased]
-- Split `View` into `View` and `ViewMut`. Note that creating a `View` still requires mutable access to the
-  archetype/world, but can be useful for passing around read-only access to a given entity.
-- The `iter`/`iter_mut` functions on archetypes now return a `View`/`ViewMut` with named component fields rather than
-  anonymous tuples, making element access less sensitive to component order changes. This also makes iteration more
-  compatible with the `ArchetypeHas` trait, as that can be used to generically access components from views.
+- Split `View` into `View` and `ViewMut`. Note that creating a `View` still requires mutable access to the archetype/world, but can be useful for passing around read-only access to a given entity.
+- The `iter`/`iter_mut` functions on archetypes now return a `View`/`ViewMut` with named component fields rather than anonymous tuples, making element access less sensitive to component order changes. This also makes iteration more compatible with the `ArchetypeHas` trait, as that can be used to generically access components from views.
+- Adding `SelectView`, `SelectViewMut`, and `SelectBorrow` for resolving views/borrows from `EntityAny` and `EntityDirectAny`. Also adding support for `EntityAny` and `EntityDirectAny` to `World::view`, `World::view_mut`, and `World::borrow`. This has a breaking change to generics using `WorldHas<A>` to access views -- the `World::view` function no longer takes an archetype as a generic argument. In generics, instead of using `World::view::<A>(entity)`, use `World::archetype[_mut]::<A>().view(entity)`. The same applies to `view_mut` and `borrow` calls.

macros/src/data.rs

@@ -35,8 +35,10 @@ pub struct DataArchetype {
 pub struct DataComponent {
     pub id: u8,
     pub name: DataComponentName,
+
     #[speedy(skip)]
-    pub default: Option<Expr>, // Used in world generation only
+    pub _default: Option<Expr>, // Preparation for future support for feature(default_field_values)
+                                // Not serialized due to being used in world generation only
 }
 
 #[derive(Debug, Readable, Writable)]
@@ -91,7 +93,7 @@ impl DataWorld {
                 components.push(DataComponent {
                     id: last_component_id.expect("internal error"),
                     name: DataComponentName::new(&component.name),
-                    default: component.default.clone(),
+                    _default: component.default.clone(),
                 });
             }
 

macros/src/generate/world.rs

@@ -37,6 +37,21 @@ pub fn generate_world(world_data: &DataWorld, raw_input: &str) -> TokenStream {
         .iter()
         .map(|archetype| format_ident!("{}Direct", archetype.name))
         .collect::<Vec<_>>();
+    let ArchetypeView = world_data
+        .archetypes
+        .iter()
+        .map(|archetype| format_ident!("{}View", archetype.name))
+        .collect::<Vec<_>>();
+    let ArchetypeViewMut = world_data
+        .archetypes
+        .iter()
+        .map(|archetype| format_ident!("{}ViewMut", archetype.name))
+        .collect::<Vec<_>>();
+    let ArchetypeBorrow = world_data
+        .archetypes
+        .iter()
+        .map(|archetype| format_ident!("{}Borrow", archetype.name))
+        .collect::<Vec<_>>();
 
     // Variables and fields
     let archetype = world_data
@@ -93,6 +108,9 @@ pub fn generate_world(world_data: &DataWorld, raw_input: &str) -> TokenStream {
             SelectArchetype,
             SelectEntity,
             SelectEntityDirect,
+            SelectView,
+            SelectViewMut,
+            SelectBorrow,
 
             #(
                 #Archetype,
@@ -246,6 +264,21 @@ pub fn generate_world(world_data: &DataWorld, raw_input: &str) -> TokenStream {
                 #( #Archetype(EntityDirect<#Archetype>), )*
             }
 
+            /// See `SelectView` in the `gecs` docs for more information.
+            pub enum SelectView<'a> {
+                #( #Archetype(#ArchetypeView<'a>), )*
+            }
+
+            /// See `SelectViewMut` in the `gecs` docs for more information.
+            pub enum SelectViewMut<'a> {
+                #( #Archetype(#ArchetypeViewMut<'a>), )*
+            }
+
+            /// See `SelectBorrow` in the `gecs` docs for more information.
+            pub enum SelectBorrow<'a> {
+                #( #Archetype(#ArchetypeBorrow<'a>), )*
+            }
+
             // Combined dispatch table for resolving both entity key types.
             /// Used internally by world queries. Not for general use.
             #[doc(hidden)]
@@ -305,6 +338,27 @@ pub fn generate_world(world_data: &DataWorld, raw_input: &str) -> TokenStream {
                     }
                 }
 
+                impl<'a> From<#ArchetypeView<'a>> for SelectView<'a> {
+                    #[inline(always)]
+                    fn from(view: #ArchetypeView<'a>) -> Self {
+                        SelectView::#Archetype(view)
+                    }
+                }
+
+                impl<'a> From<#ArchetypeViewMut<'a>> for SelectViewMut<'a> {
+                    #[inline(always)]
+                    fn from(view: #ArchetypeViewMut<'a>) -> Self {
+                        SelectViewMut::#Archetype(view)
+                    }
+                }
+
+                impl<'a> From<#ArchetypeBorrow<'a>> for SelectBorrow<'a> {
+                    #[inline(always)]
+                    fn from(view: #ArchetypeBorrow<'a>) -> Self {
+                        SelectBorrow::#Archetype(view)
+                    }
+                }
+
                 impl From<EntityDirect<#Archetype>> for #__WorldSelectTotal {
                     #[inline(always)]
                     fn from(entity: EntityDirect<#Archetype>) -> Self {
@@ -464,6 +518,39 @@ pub fn generate_world(world_data: &DataWorld, raw_input: &str) -> TokenStream {
                 }
             }
 
+            impl<'a> From<SelectView<'a>> for SelectArchetype {
+                #[inline(always)]
+                fn from(view: SelectView<'a>) -> Self {
+                    match view {
+                        #(
+                            SelectView::#Archetype(_) => SelectArchetype::#Archetype,
+                        )*
+                    }
+                }
+            }
+
+            impl<'a> From<SelectViewMut<'a>> for SelectArchetype {
+                #[inline(always)]
+                fn from(view: SelectViewMut<'a>) -> Self {
+                    match view {
+                        #(
+                            SelectViewMut::#Archetype(_) => SelectArchetype::#Archetype,
+                        )*
+                    }
+                }
+            }
+
+            impl<'a> From<SelectBorrow<'a>> for SelectArchetype {
+                #[inline(always)]
+                fn from(view: SelectBorrow<'a>) -> Self {
+                    match view {
+                        #(
+                            SelectBorrow::#Archetype(_) => SelectArchetype::#Archetype,
+                        )*
+                    }
+                }
+            }
+
             impl TryFrom<ArchetypeId> for SelectArchetype {
                 type Error = EcsError;
 
@@ -492,6 +579,20 @@ pub fn generate_world(world_data: &DataWorld, raw_input: &str) -> TokenStream {
                 }
             }
 
+            impl TryFrom<EntityDirectAny> for SelectArchetype {
+                type Error = EcsError;
+
+                #[inline(always)]
+                fn try_from(entity: EntityDirectAny) -> Result<Self, EcsError> {
+                    match entity.archetype_id() {
+                        #(
+                            #Archetype::ARCHETYPE_ID => Ok(SelectArchetype::#Archetype),
+                        )*
+                        _ => Err(EcsError::InvalidEntityType),
+                    }
+                }
+            }
+
             impl TryFrom<EntityAny> for SelectEntity {
                 type Error = EcsError;
 
@@ -647,6 +748,84 @@ pub fn generate_world(world_data: &DataWorld, raw_input: &str) -> TokenStream {
                     (*entity).try_into()
                 }
             }
+
+            impl<'a> EntityKeySelectable<'a, #World> for EntityAny {
+                type View = SelectView<'a>;
+                type ViewMut = SelectViewMut<'a>;
+                type Borrow = SelectBorrow<'a>;
+
+                #[inline(always)]
+                fn resolve_view(self, world: &'a mut #World) -> Option<Self::View> {
+                    match self.try_into() {
+                        #(
+                            Ok(SelectEntity::#Archetype(entity)) =>
+                                world.#archetype.view(entity).map(|v| v.into()),
+                        )*
+                        Err(_) => panic!("invalid entity type"),
+                    }
+                }
+
+                #[inline(always)]
+                fn resolve_view_mut(self, world: &'a mut #World) -> Option<Self::ViewMut> {
+                    match self.try_into() {
+                        #(
+                            Ok(SelectEntity::#Archetype(entity)) =>
+                                world.#archetype.view_mut(entity).map(|v| v.into()),
+                        )*
+                        Err(_) => panic!("invalid entity type"),
+                    }
+                }
+
+                #[inline(always)]
+                fn resolve_borrow(self, world: &'a #World) -> Option<Self::Borrow> {
+                    match self.try_into() {
+                        #(
+                            Ok(SelectEntity::#Archetype(entity)) =>
+                                world.#archetype.borrow(entity).map(|v| v.into()),
+                        )*
+                        Err(_) => panic!("invalid entity type"),
+                    }
+                }
+            }
+
+            impl<'a> EntityKeySelectable<'a, #World> for EntityDirectAny {
+                type View = SelectView<'a>;
+                type ViewMut = SelectViewMut<'a>;
+                type Borrow = SelectBorrow<'a>;
+
+                #[inline(always)]
+                fn resolve_view(self, world: &'a mut #World) -> Option<Self::View> {
+                    match self.try_into() {
+                        #(
+                            Ok(SelectEntityDirect::#Archetype(entity)) =>
+                                world.#archetype.view(entity).map(|v| v.into()),
+                        )*
+                        Err(_) => panic!("invalid entity type"),
+                    }
+                }
+
+                #[inline(always)]
+                fn resolve_view_mut(self, world: &'a mut #World) -> Option<Self::ViewMut> {
+                    match self.try_into() {
+                        #(
+                            Ok(SelectEntityDirect::#Archetype(entity)) =>
+                                world.#archetype.view_mut(entity).map(|v| v.into()),
+                        )*
+                        Err(_) => panic!("invalid entity type"),
+                    }
+                }
+
+                #[inline(always)]
+                fn resolve_borrow(self, world: &'a #World) -> Option<Self::Borrow> {
+                    match self.try_into() {
+                        #(
+                            Ok(SelectEntityDirect::#Archetype(entity)) =>
+                                world.#archetype.borrow(entity).map(|v| v.into()),
+                        )*
+                        Err(_) => panic!("invalid entity type"),
+                    }
+                }
+            }
         }
 
         #[macro_export]

src/lib.rs

@@ -789,6 +789,21 @@ pub enum SelectEntity {}
 #[cfg(doc)]
 pub enum SelectEntityDirect {}
 
+/// Similar to SelectEntity, but stores a [`View`](crate::traits::View) for the matched
+/// archetype. Returned as a result of the `view` function on [`World`](crate::traits::World).
+#[cfg(doc)]
+pub enum SelectView {}
+
+/// Similar to SelectEntity, but stores a [`ViewMut`](crate::traits::ViewMut) for the matched
+/// archetype. Returned as a result of the `view_mut` function on [`World`](crate::traits::World).
+#[cfg(doc)]
+pub enum SelectViewMut {}
+
+/// Similar to SelectEntity, but stores a [`Borrow`](crate::traits::Borrow) for the matched
+/// archetype. Returned as a result of the `borrow` function on [`World`](crate::traits::World).
+#[cfg(doc)]
+pub enum SelectBorrow {}
+
 #[cfg(not(doc))]
 pub use gecs_macros::{ecs_component_id, ecs_world};
 
@@ -803,7 +818,7 @@ pub mod prelude {
 
     pub use iter::{EcsStepDestroy, EcsStep};
 
-    pub use traits::EntityKey;
+    pub use traits::{EntityKey, EntityKeyTyped, EntityKeySelectable};
     pub use traits::{WorldCanResolve, ArchetypeCanResolve, StorageCanResolve};
 
     pub use traits::{World, WorldHas};