meta: further review meta container vtables

TODO

@@ -17,7 +17,7 @@ TODO (high prio):
 * view with entity storage: begin/end should return filtered iterators
 * update view doc: single vs multi type views are no longer a thing actually
 * meta container: add value type to resize
-* meta: cbegin/cend for meta containers, avoid the branch
+* meta: drop unused return type from meta container vtables
 * ===> TEST: review view tests after the last changes
 
 WIP:

src/entt/meta/container.hpp

@@ -64,7 +64,7 @@ class basic_meta_sequence_container_traits {
     using size_type = typename meta_sequence_container::size_type;
     using iterator = typename meta_sequence_container::iterator;
 
-    static size_type basic_vtable(const operation op, const void *container, const void *value, iterator *it) {
+    static size_type basic_vtable(const operation op, const void *container, const void *value, meta_any *elem) {
         switch(op) {
         case operation::size:
             return static_cast<const Type *>(container)->size();
@@ -90,26 +90,25 @@ class basic_meta_sequence_container_traits {
                 break;
             }
         case operation::begin:
-            it->rebind(static_cast<Type *>(const_cast<void *>(container))->begin());
+            static_cast<iterator *>(const_cast<void *>(value))->rebind(static_cast<Type *>(const_cast<void *>(container))->begin());
             return true;
         case operation::cbegin:
-            it->rebind(static_cast<const Type *>(container)->begin());
+            static_cast<iterator *>(const_cast<void *>(value))->rebind(static_cast<const Type *>(container)->begin());
             return true;
         case operation::end:
-            it->rebind(static_cast<Type *>(const_cast<void *>(container))->end());
+            static_cast<iterator *>(const_cast<void *>(value))->rebind(static_cast<Type *>(const_cast<void *>(container))->end());
             return true;
         case operation::cend:
-            it->rebind(static_cast<const Type *>(container)->end());
+            static_cast<iterator *>(const_cast<void *>(value))->rebind(static_cast<const Type *>(container)->end());
             return true;
         case operation::insert:
             if constexpr(internal::dynamic_sequence_container<Type>::value) {
-                auto *const non_const = any_cast<typename Type::iterator>(&it->base());
-                typename Type::const_iterator underlying{non_const ? *non_const : any_cast<const typename Type::const_iterator &>(it->base())};
-
                 // this abomination is necessary because only on macos value_type and const_reference are different types for std::vector<bool>
-                if(auto &as_any = *static_cast<meta_any *>(const_cast<void *>(value)); as_any.allow_cast<typename Type::const_reference>() || as_any.allow_cast<typename Type::value_type>()) {
+                if(auto &as_any = *elem; as_any.allow_cast<typename Type::const_reference>() || as_any.allow_cast<typename Type::value_type>()) {
+                    auto &it = *static_cast<iterator *>(const_cast<void *>(value));
+                    auto *const non_const = any_cast<typename Type::iterator>(&it.base());
                     const auto *element = as_any.try_cast<std::remove_reference_t<typename Type::const_reference>>();
-                    it->rebind(static_cast<Type *>(const_cast<void *>(container))->insert(underlying, element ? *element : as_any.cast<typename Type::value_type>()));
+                    it.rebind(static_cast<Type *>(const_cast<void *>(container))->insert(non_const ? *non_const : any_cast<const typename Type::const_iterator &>(it.base()), element ? *element : as_any.cast<typename Type::value_type>()));
                     return true;
                 }
             }
@@ -117,9 +116,9 @@ class basic_meta_sequence_container_traits {
             break;
         case operation::erase:
             if constexpr(internal::dynamic_sequence_container<Type>::value) {
-                auto *const non_const = any_cast<typename Type::iterator>(&it->base());
-                typename Type::const_iterator underlying{non_const ? *non_const : any_cast<const typename Type::const_iterator &>(it->base())};
-                it->rebind(static_cast<Type *>(const_cast<void *>(container))->erase(underlying));
+                auto &it = *static_cast<iterator *>(const_cast<void *>(value));
+                auto *const non_const = any_cast<typename Type::iterator>(&it.base());
+                it.rebind(static_cast<Type *>(const_cast<void *>(container))->erase(non_const ? *non_const : any_cast<const typename Type::const_iterator &>(it.base())));
                 return true;
             } else {
                 break;
@@ -146,7 +145,7 @@ class basic_meta_associative_container_traits {
     using size_type = typename meta_associative_container::size_type;
     using iterator = typename meta_associative_container::iterator;
 
-    static size_type basic_vtable(const operation op, const void *container, const void *key, const void *value, iterator *it) {
+    static size_type basic_vtable(const operation op, const void *container, const void *key, const void *value) {
         switch(op) {
         case operation::size:
             return static_cast<const Type *>(const_cast<void *>(container))->size();
@@ -161,16 +160,16 @@ class basic_meta_associative_container_traits {
                 break;
             }
         case operation::begin:
-            it->rebind<key_only>(static_cast<Type *>(const_cast<void *>(container))->begin());
+            static_cast<iterator *>(const_cast<void *>(value))->rebind<key_only>(static_cast<Type *>(const_cast<void *>(container))->begin());
             return true;
         case operation::cbegin:
-            it->rebind<key_only>(static_cast<const Type *>(container)->begin());
+            static_cast<iterator *>(const_cast<void *>(value))->rebind<key_only>(static_cast<const Type *>(container)->begin());
             return true;
         case operation::end:
-            it->rebind<key_only>(static_cast<Type *>(const_cast<void *>(container))->end());
+            static_cast<iterator *>(const_cast<void *>(value))->rebind<key_only>(static_cast<Type *>(const_cast<void *>(container))->end());
             return true;
         case operation::cend:
-            it->rebind<key_only>(static_cast<const Type *>(container)->end());
+            static_cast<iterator *>(const_cast<void *>(value))->rebind<key_only>(static_cast<const Type *>(container)->end());
             return true;
         case operation::insert:
             if constexpr(key_only) {
@@ -181,10 +180,10 @@ class basic_meta_associative_container_traits {
         case operation::erase:
             return static_cast<Type *>(const_cast<void *>(container))->erase(*static_cast<const typename Type::key_type *>(key));
         case operation::find:
-            it->rebind<key_only>(static_cast<Type *>(const_cast<void *>(container))->find(*static_cast<const typename Type::key_type *>(key)));
+            static_cast<iterator *>(const_cast<void *>(value))->rebind<key_only>(static_cast<Type *>(const_cast<void *>(container))->find(*static_cast<const typename Type::key_type *>(key)));
             return true;
         case operation::cfind:
-            it->rebind<key_only>(static_cast<const Type *>(container)->find(*static_cast<const typename Type::key_type *>(key)));
+            static_cast<iterator *>(const_cast<void *>(value))->rebind<key_only>(static_cast<const Type *>(container)->find(*static_cast<const typename Type::key_type *>(key)));
             return true;
         }
 

src/entt/meta/meta.hpp

@@ -75,7 +75,7 @@ public:
 private:
     const meta_ctx *ctx{};
     internal::meta_type_node (*value_type_node)(const internal::meta_context &){};
-    size_type (*vtable)(const operation, const void *, const void *, iterator *){};
+    size_type (*vtable)(const operation, const void *, const void *, meta_any *){};
     any storage{};
 };
 
@@ -137,7 +137,7 @@ private:
     internal::meta_type_node (*key_type_node)(const internal::meta_context &){};
     internal::meta_type_node (*mapped_type_node)(const internal::meta_context &){};
     internal::meta_type_node (*value_type_node)(const internal::meta_context &){};
-    size_type (*vtable)(const operation, const void *, const void *, const void *, iterator *){};
+    size_type (*vtable)(const operation, const void *, const void *, const void *){};
     any storage{};
 };
 
@@ -1808,7 +1808,7 @@ inline bool meta_sequence_container::reserve(const size_type sz) {
  */
 [[nodiscard]] inline meta_sequence_container::iterator meta_sequence_container::begin() {
     iterator it{*ctx};
-    vtable(storage.policy() == any_policy::cref ? operation::cbegin : operation::begin, std::as_const(storage).data(), nullptr, &it);
+    vtable(storage.policy() == any_policy::cref ? operation::cbegin : operation::begin, std::as_const(storage).data(), &it, nullptr);
     return it;
 }
 
@@ -1818,7 +1818,7 @@ inline bool meta_sequence_container::reserve(const size_type sz) {
  */
 [[nodiscard]] inline meta_sequence_container::iterator meta_sequence_container::end() {
     iterator it{*ctx};
-    vtable(storage.policy() == any_policy::cref ? operation::cend : operation::end, std::as_const(storage).data(), nullptr, &it);
+    vtable(storage.policy() == any_policy::cref ? operation::cend : operation::end, std::as_const(storage).data(), &it, nullptr);
     return it;
 }
 
@@ -1829,7 +1829,7 @@ inline bool meta_sequence_container::reserve(const size_type sz) {
  * @return A possibly invalid iterator to the inserted element.
  */
 inline meta_sequence_container::iterator meta_sequence_container::insert(iterator it, meta_any value) {
-    return ((storage.policy() != any_policy::cref) && vtable(operation::insert, storage.data(), &value, &it)) ? it : iterator{*ctx};
+    return ((storage.policy() != any_policy::cref) && vtable(operation::insert, storage.data(), &it, &value)) ? it : iterator{*ctx};
 }
 
 /**
@@ -1838,7 +1838,7 @@ inline meta_sequence_container::iterator meta_sequence_container::insert(iterato
  * @return A possibly invalid iterator following the last removed element.
  */
 inline meta_sequence_container::iterator meta_sequence_container::erase(iterator it) {
-    return ((storage.policy() != any_policy::cref) && vtable(operation::erase, storage.data(), nullptr, &it)) ? it : iterator{*ctx};
+    return ((storage.policy() != any_policy::cref) && vtable(operation::erase, storage.data(), &it, nullptr)) ? it : iterator{*ctx};
 }
 
 /**
@@ -1884,30 +1884,30 @@ inline meta_sequence_container::iterator meta_sequence_container::erase(iterator
 
 /*! @copydoc meta_sequence_container::size */
 [[nodiscard]] inline meta_associative_container::size_type meta_associative_container::size() const noexcept {
-    return vtable(operation::size, std::as_const(storage).data(), nullptr, nullptr, nullptr);
+    return vtable(operation::size, std::as_const(storage).data(), nullptr, nullptr);
 }
 
 /*! @copydoc meta_sequence_container::clear */
 inline bool meta_associative_container::clear() {
-    return (storage.policy() != any_policy::cref) && vtable(operation::clear, storage.data(), nullptr, nullptr, nullptr);
+    return (storage.policy() != any_policy::cref) && vtable(operation::clear, storage.data(), nullptr, nullptr);
 }
 
 /*! @copydoc meta_sequence_container::reserve */
 inline bool meta_associative_container::reserve(const size_type sz) {
-    return (storage.policy() != any_policy::cref) && vtable(operation::reserve, storage.data(), nullptr, &sz, nullptr);
+    return (storage.policy() != any_policy::cref) && vtable(operation::reserve, storage.data(), nullptr, &sz);
 }
 
 /*! @copydoc meta_sequence_container::begin */
 [[nodiscard]] inline meta_associative_container::iterator meta_associative_container::begin() {
     iterator it{*ctx};
-    vtable(storage.policy() == any_policy::cref ? operation::cbegin : operation::begin, std::as_const(storage).data(), nullptr, nullptr, &it);
+    vtable(storage.policy() == any_policy::cref ? operation::cbegin : operation::begin, std::as_const(storage).data(), nullptr, &it);
     return it;
 }
 
 /*! @copydoc meta_sequence_container::end */
 [[nodiscard]] inline meta_associative_container::iterator meta_associative_container::end() {
     iterator it{*ctx};
-    vtable(storage.policy() == any_policy::cref ? operation::cend : operation::end, std::as_const(storage).data(), nullptr, nullptr, &it);
+    vtable(storage.policy() == any_policy::cref ? operation::cend : operation::end, std::as_const(storage).data(), nullptr, &it);
     return it;
 }
 
@@ -1919,7 +1919,7 @@ inline bool meta_associative_container::reserve(const size_type sz) {
  */
 inline bool meta_associative_container::insert(meta_any key, meta_any value = {}) {
     const bool valid_key_value = key.allow_cast(meta_type{*ctx, key_type_node(internal::meta_context::from(*ctx))}) && (!mapped_type_node || value.allow_cast(meta_type{*ctx, mapped_type_node(internal::meta_context::from(*ctx))}));
-    return valid_key_value && (storage.policy() != any_policy::cref) && vtable(operation::insert, storage.data(), std::as_const(key).data(), std::as_const(value).data(), nullptr);
+    return valid_key_value && (storage.policy() != any_policy::cref) && vtable(operation::insert, storage.data(), std::as_const(key).data(), std::as_const(value).data());
 }
 
 /**
@@ -1929,7 +1929,7 @@ inline bool meta_associative_container::insert(meta_any key, meta_any value = {}
  */
 inline meta_associative_container::size_type meta_associative_container::erase(meta_any key) {
     const bool valid_key = key.allow_cast(meta_type{*ctx, key_type_node(internal::meta_context::from(*ctx))});
-    return valid_key && (storage.policy() != any_policy::cref) && vtable(operation::erase, storage.data(), std::as_const(key).data(), nullptr, nullptr);
+    return valid_key && (storage.policy() != any_policy::cref) && vtable(operation::erase, storage.data(), std::as_const(key).data(), nullptr);
 }
 
 /**
@@ -1939,7 +1939,7 @@ inline meta_associative_container::size_type meta_associative_container::erase(m
  */
 [[nodiscard]] inline meta_associative_container::iterator meta_associative_container::find(meta_any key) {
     iterator it{*ctx};
-    key.allow_cast(meta_type{*ctx, key_type_node(internal::meta_context::from(*ctx))}) && vtable(storage.policy() == any_policy::cref ? operation::cfind : operation::find, std::as_const(storage).data(), std::as_const(key).data(), nullptr, &it);
+    key.allow_cast(meta_type{*ctx, key_type_node(internal::meta_context::from(*ctx))}) && vtable(storage.policy() == any_policy::cref ? operation::cfind : operation::find, std::as_const(storage).data(), std::as_const(key).data(), &it);
     return it;
 }