meta: split begin/cbegin and end/cend for meta assoc containers, review vtable

src/entt/meta/container.hpp

@@ -146,51 +146,45 @@ 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 *cvalue, void *value, const void *key, iterator *it) {
+    static size_type basic_vtable(const operation op, const void *container, const void *key, const void *value, iterator *it) {
         switch(op) {
         case operation::size:
-            return static_cast<const Type *>(cvalue)->size();
+            return static_cast<const Type *>(const_cast<void *>(container))->size();
         case operation::clear:
-            static_cast<Type *>(value)->clear();
+            static_cast<Type *>(const_cast<void *>(container))->clear();
             return true;
         case operation::reserve:
             if constexpr(internal::reserve_aware_container<Type>::value) {
-                static_cast<Type *>(value)->reserve(*static_cast<const size_type *>(cvalue));
+                static_cast<Type *>(const_cast<void *>(container))->reserve(*static_cast<const size_type *>(value));
                 return true;
             } else {
                 break;
             }
         case operation::begin:
-            if(value) {
-                it->rebind<key_only>(static_cast<Type *>(value)->begin());
-            } else {
-                it->rebind<key_only>(static_cast<const Type *>(cvalue)->begin());
-            }
-
+            it->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());
             return true;
         case operation::end:
-            if(value) {
-                it->rebind<key_only>(static_cast<Type *>(value)->end());
-            } else {
-                it->rebind<key_only>(static_cast<const Type *>(cvalue)->end());
-            }
-
+            it->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());
             return true;
         case operation::insert:
             if constexpr(key_only) {
-                return static_cast<Type *>(value)->insert(*static_cast<const typename Type::key_type *>(key)).second;
+                return static_cast<Type *>(const_cast<void *>(container))->insert(*static_cast<const typename Type::key_type *>(key)).second;
             } else {
-                return static_cast<Type *>(value)->emplace(*static_cast<const typename Type::key_type *>(key), *static_cast<const typename Type::mapped_type *>(cvalue)).second;
+                return static_cast<Type *>(const_cast<void *>(container))->emplace(*static_cast<const typename Type::key_type *>(key), *static_cast<const typename Type::mapped_type *>(value)).second;
             }
         case operation::erase:
-            return static_cast<Type *>(value)->erase(*static_cast<const typename Type::key_type *>(key));
+            return static_cast<Type *>(const_cast<void *>(container))->erase(*static_cast<const typename Type::key_type *>(key));
         case operation::find:
-            if(value) {
-                it->rebind<key_only>(static_cast<Type *>(value)->find(*static_cast<const typename Type::key_type *>(key)));
-            } else {
-                it->rebind<key_only>(static_cast<const Type *>(cvalue)->find(*static_cast<const typename Type::key_type *>(key)));
-            }
-
+            it->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)));
             return true;
         }
 

src/entt/meta/meta.hpp

@@ -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 *, void *, const void *, iterator *){};
+    size_type (*vtable)(const operation, const void *, const void *, const void *, iterator *){};
     any storage{};
 };
 
@@ -1889,27 +1889,25 @@ inline meta_sequence_container::iterator meta_sequence_container::erase(iterator
 
 /*! @copydoc meta_sequence_container::clear */
 inline bool meta_associative_container::clear() {
-    return (storage.policy() != any_policy::cref) && vtable(operation::clear, nullptr, storage.data(), nullptr, nullptr);
+    return (storage.policy() != any_policy::cref) && vtable(operation::clear, storage.data(), nullptr, 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, &sz, storage.data(), nullptr, nullptr);
+    return (storage.policy() != any_policy::cref) && vtable(operation::reserve, storage.data(), nullptr, &sz, nullptr);
 }
 
 /*! @copydoc meta_sequence_container::begin */
 [[nodiscard]] inline meta_associative_container::iterator meta_associative_container::begin() {
     iterator it{*ctx};
-    const void *data = std::as_const(storage).data();
-    vtable(operation::begin, data, storage.policy() == any_policy::cref ? nullptr : const_cast<void *>(data), nullptr, &it);
+    vtable(storage.policy() == any_policy::cref ? operation::cbegin : operation::begin, std::as_const(storage).data(), nullptr, nullptr, &it);
     return it;
 }
 
 /*! @copydoc meta_sequence_container::end */
 [[nodiscard]] inline meta_associative_container::iterator meta_associative_container::end() {
     iterator it{*ctx};
-    const void *data = std::as_const(storage).data();
-    vtable(operation::end, data, storage.policy() == any_policy::cref ? nullptr : const_cast<void *>(data), nullptr, &it);
+    vtable(storage.policy() == any_policy::cref ? operation::cend : operation::end, std::as_const(storage).data(), nullptr, nullptr, &it);
     return it;
 }
 
@@ -1921,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, std::as_const(value).data(), storage.data(), std::as_const(key).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(), nullptr);
 }
 
 /**
@@ -1931,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, nullptr, storage.data(), std::as_const(key).data(), nullptr);
+    return valid_key && (storage.policy() != any_policy::cref) && vtable(operation::erase, storage.data(), std::as_const(key).data(), nullptr, nullptr);
 }
 
 /**
@@ -1941,8 +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};
-    const void *data = std::as_const(storage).data();
-    key.allow_cast(meta_type{*ctx, key_type_node(internal::meta_context::from(*ctx))}) && vtable(operation::find, data, storage.policy() == any_policy::cref ? nullptr : const_cast<void *>(data), std::as_const(key).data(), &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(), nullptr, &it);
     return it;
 }
 

src/entt/meta/type_traits.hpp

@@ -31,10 +31,13 @@ enum class meta_associative_container_operation {
     clear,
     reserve,
     begin,
+    cbegin,
     end,
+    cend,
     insert,
     erase,
-    find
+    find,
+    cfind
 };
 
 } // namespace internal