component:

* make component_traits treat void properly
* drop ignore_as_empty_v

src/entt/entity/component.hpp

@@ -17,6 +17,9 @@ namespace internal {
 template<typename Type, typename = void>
 struct in_place_delete: std::bool_constant<!(std::is_move_constructible_v<Type> && std::is_move_assignable_v<Type>)> {};
 
+template<>
+struct in_place_delete<void>: std::false_type {};
+
 template<typename Type>
 struct in_place_delete<Type, std::enable_if_t<Type::in_place_delete>>
     : std::true_type {};
@@ -24,6 +27,9 @@ struct in_place_delete<Type, std::enable_if_t<Type::in_place_delete>>
 template<typename Type, typename = void>
 struct page_size: std::integral_constant<std::size_t, !std::is_empty_v<ENTT_ETO_TYPE(Type)> * ENTT_PACKED_PAGE> {};
 
+template<>
+struct page_size<void>: std::integral_constant<std::size_t, 0u> {};
+
 template<typename Type>
 struct page_size<Type, std::enable_if_t<std::is_convertible_v<decltype(Type::page_size), std::size_t>>>
     : std::integral_constant<std::size_t, Type::page_size> {};
@@ -52,13 +58,6 @@ struct component_traits {
     static constexpr std::size_t page_size = internal::page_size<Type>::value;
 };
 
-/**
- * @brief Helper variable template.
- * @tparam Type Type of component.
- */
-template<typename Type>
-inline constexpr bool ignore_as_empty_v = (std::is_void_v<Type> || component_traits<Type>::page_size == 0u);
-
 } // namespace entt
 
 #endif

src/entt/entity/group.hpp

@@ -28,7 +28,7 @@ template<typename It, typename... Owned, typename... Get>
 class extended_group_iterator<It, owned_t<Owned...>, get_t<Get...>> {
     template<typename Type>
     auto index_to_element([[maybe_unused]] Type &cpool) const {
-        if constexpr(ignore_as_empty_v<typename Type::value_type>) {
+        if constexpr(Type::traits_type::page_size == 0u) {
             return std::make_tuple();
         } else {
             return std::forward_as_tuple(cpool.rbegin()[it.index()]);

src/entt/entity/snapshot.hpp

@@ -165,7 +165,7 @@ class basic_snapshot_loader {
 
         archive(length);
 
-        if constexpr(ignore_as_empty_v<Component>) {
+        if constexpr(std::is_empty_v<Component>) {
             while(length--) {
                 archive(entt);
                 const auto entity = reg->valid(entt) ? entt : reg->create(entt);
@@ -382,7 +382,7 @@ class basic_continuous_loader {
 
         archive(length);
 
-        if constexpr(ignore_as_empty_v<Component>) {
+        if constexpr(std::is_empty_v<Component>) {
             while(length--) {
                 archive(entt);
                 restore(entt);

src/entt/entity/storage.hpp

@@ -745,7 +745,7 @@ private:
 
 /*! @copydoc basic_storage */
 template<typename Type, typename Entity, typename Allocator>
-class basic_storage<Type, Entity, Allocator, std::enable_if_t<ignore_as_empty_v<Type>>>
+class basic_storage<Type, Entity, Allocator, std::enable_if_t<component_traits<Type>::page_size == 0u>>
     : public basic_sparse_set<Entity, typename std::allocator_traits<Allocator>::template rebind_alloc<Entity>> {
     using alloc_traits = std::allocator_traits<Allocator>;
     static_assert(std::is_same_v<typename alloc_traits::value_type, Type>, "Invalid value type");

src/entt/entity/view.hpp

@@ -803,7 +803,7 @@ public:
             for(const auto pack: each()) {
                 std::apply(func, pack);
             }
-        } else if constexpr(ignore_as_empty_v<typename Get::value_type>) {
+        } else if constexpr(Get::traits_type::page_size == 0u) {
             for(size_type pos{}, last = size(); pos < last; ++pos) {
                 func();
             }

test/entt/entity/component.cpp

@@ -32,17 +32,14 @@ struct entt::component_traits<traits_based> {
 TEST(Component, VoidType) {
     using traits_type = entt::component_traits<void>;
 
-    static_assert(traits_type::in_place_delete);
-    static_assert(entt::ignore_as_empty_v<typename traits_type::type>);
-    // we don't really care about this thanks to ignore_as_empty_v
-    static_assert(traits_type::page_size != 0u);
+    static_assert(!traits_type::in_place_delete);
+    static_assert(traits_type::page_size == 0u);
 }
 
 TEST(Component, Empty) {
     using traits_type = entt::component_traits<empty>;
 
     static_assert(!traits_type::in_place_delete);
-    static_assert(entt::ignore_as_empty_v<typename traits_type::type>);
     static_assert(traits_type::page_size == 0u);
 }
 
@@ -50,7 +47,6 @@ TEST(Component, NonEmpty) {
     using traits_type = entt::component_traits<non_empty>;
 
     static_assert(!traits_type::in_place_delete);
-    static_assert(!entt::ignore_as_empty_v<typename traits_type::type>);
     static_assert(traits_type::page_size == ENTT_PACKED_PAGE);
 }
 
@@ -58,7 +54,6 @@ TEST(Component, NonMovable) {
     using traits_type = entt::component_traits<non_movable>;
 
     static_assert(traits_type::in_place_delete);
-    static_assert(!entt::ignore_as_empty_v<typename traits_type::type>);
     static_assert(traits_type::page_size == ENTT_PACKED_PAGE);
 }
 
@@ -66,7 +61,6 @@ TEST(Component, SelfContained) {
     using traits_type = entt::component_traits<self_contained>;
 
     static_assert(traits_type::in_place_delete);
-    static_assert(!entt::ignore_as_empty_v<typename traits_type::type>);
     static_assert(traits_type::page_size == 4u);
 }
 
@@ -74,6 +68,5 @@ TEST(Component, TraitsBased) {
     using traits_type = entt::component_traits<traits_based>;
 
     static_assert(!traits_type::in_place_delete);
-    static_assert(!entt::ignore_as_empty_v<typename traits_type::type>);
     static_assert(traits_type::page_size == 8u);
 }