meta: make the non-consteness of the value-or-container explicit in the meta container vtable

src/entt/meta/container.hpp

@@ -52,7 +52,7 @@ struct 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 meta_ctx &ctx, const void *container, const void *value, iterator *it) {
+    static size_type basic_vtable(const operation op, const meta_ctx &ctx, const void *container, void *value, iterator *it) {
         switch(const Type *cont = static_cast<const Type *>(container); op) {
         case operation::size:
             return cont->size();
@@ -65,14 +65,14 @@ struct basic_meta_sequence_container_traits {
             }
         case operation::reserve:
             if constexpr(reserve_aware_container<Type>::value) {
-                const_cast<Type *>(cont)->reserve(*static_cast<const size_type *>(value));
+                const_cast<Type *>(cont)->reserve(*static_cast<size_type *>(value));
                 return true;
             } else {
                 break;
             }
         case operation::resize:
             if constexpr(dynamic_sequence_container<Type>::value) {
-                const_cast<Type *>(cont)->resize(*static_cast<const size_type *>(value));
+                const_cast<Type *>(cont)->resize(*static_cast<size_type *>(value));
                 return true;
             } else {
                 break;
@@ -101,9 +101,9 @@ struct basic_meta_sequence_container_traits {
 
                 if(op == operation::insert) {
                     // this abomination is necessary because only on macos value_type and const_reference are different types for std::vector<bool>
-                    if(static_cast<meta_any *>(const_cast<void *>(value))->allow_cast<typename Type::const_reference>() || static_cast<meta_any *>(const_cast<void *>(value))->allow_cast<typename Type::value_type>()) {
-                        const auto *element = static_cast<meta_any *>(const_cast<void *>(value))->try_cast<std::remove_reference_t<typename Type::const_reference>>();
-                        *it = iterator{ctx, const_cast<Type *>(cont)->insert(underlying, element ? *element : static_cast<meta_any *>(const_cast<void *>(value))->cast<typename Type::value_type>())};
+                    if(static_cast<meta_any *>(value)->allow_cast<typename Type::const_reference>() || static_cast<meta_any *>(value)->allow_cast<typename Type::value_type>()) {
+                        const auto *element = static_cast<meta_any *>(value)->try_cast<std::remove_reference_t<typename Type::const_reference>>();
+                        *it = iterator{ctx, const_cast<Type *>(cont)->insert(underlying, element ? *element : static_cast<meta_any *>(value)->cast<typename Type::value_type>())};
                         return true;
                     }
                 } else {
@@ -129,7 +129,7 @@ struct basic_meta_associative_container_traits {
 
     static constexpr auto key_only = key_only_associative_container<Type>::value;
 
-    static size_type basic_vtable(const operation op, const meta_ctx &ctx, const void *container, meta_any *key, const void *value, iterator *it) {
+    static size_type basic_vtable(const operation op, const meta_ctx &ctx, const void *container, meta_any *key, void *value, iterator *it) {
         switch(const Type *cont = static_cast<const Type *>(container); op) {
         case operation::size:
             return cont->size();
@@ -138,7 +138,7 @@ struct basic_meta_associative_container_traits {
             return true;
         case operation::reserve:
             if constexpr(reserve_aware_container<Type>::value) {
-                const_cast<Type *>(cont)->reserve(*static_cast<const size_type *>(value));
+                const_cast<Type *>(cont)->reserve(*static_cast<size_type *>(value));
                 return true;
             } else {
                 break;
@@ -164,7 +164,7 @@ struct basic_meta_associative_container_traits {
                 if constexpr(key_only) {
                     return const_cast<Type *>(cont)->insert(key->cast<const typename Type::key_type &>()).second;
                 } else {
-                    meta_any *val = static_cast<meta_any *>(const_cast<void *>(value));
+                    meta_any *val = static_cast<meta_any *>(value);
                     return val->allow_cast<const typename Type::mapped_type &>() && const_cast<Type *>(cont)->emplace(key->cast<const typename Type::key_type &>(), val->cast<const typename Type::mapped_type &>()).second;
                 }
             }
@@ -185,7 +185,7 @@ struct basic_meta_associative_container_traits {
                 }
 
                 return true;
-            }
+            }   
 
             break;
         }

src/entt/meta/meta.hpp

@@ -108,7 +108,7 @@ public:
 private:
     const meta_ctx *ctx{};
     internal::meta_type_node (*value_type_node)(const internal::meta_context &){};
-    size_type (*vtable)(const operation, const meta_ctx &, const void *, const void *, iterator *){};
+    size_type (*vtable)(const operation, const meta_ctx &, const void *, void *, iterator *){};
     any storage{};
 };
 
@@ -170,7 +170,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 meta_ctx &, const void *, meta_any *, const void *, iterator *){};
+    size_type (*vtable)(const operation, const meta_ctx &, const void *, meta_any *, void *, iterator *){};
     any storage{};
 };
 
@@ -1875,7 +1875,8 @@ private:
  * @return True in case of success, false otherwise.
  */
 inline bool meta_sequence_container::resize(const size_type sz) {
-    return (storage.policy() != any_policy::cref) && vtable(operation::resize, *ctx, storage.data(), &sz, nullptr);
+    auto local = sz;
+    return (storage.policy() != any_policy::cref) && vtable(operation::resize, *ctx, storage.data(), &local, nullptr);
 }
 
 /**
@@ -1892,7 +1893,8 @@ inline bool meta_sequence_container::clear() {
  * @return True in case of success, false otherwise.
  */
 inline bool meta_sequence_container::reserve(const size_type sz) {
-    return (storage.policy() != any_policy::cref) && vtable(operation::reserve, *ctx, storage.data(), &sz, nullptr);
+    auto local = sz;
+    return (storage.policy() != any_policy::cref) && vtable(operation::reserve, *ctx, storage.data(), &local, nullptr);
 }
 
 /**
@@ -1901,7 +1903,8 @@ inline bool meta_sequence_container::reserve(const size_type sz) {
  */
 [[nodiscard]] inline meta_sequence_container::iterator meta_sequence_container::begin() {
     iterator it{};
-    vtable(operation::begin, *ctx, std::as_const(storage).data(), storage.policy() == any_policy::cref ? nullptr : this, &it);
+    const void *data = std::as_const(storage).data();
+    vtable(operation::begin, *ctx, data, storage.policy() == any_policy::cref ? nullptr : const_cast<void *>(data), &it);
     return it;
 }
 
@@ -1911,7 +1914,8 @@ inline bool meta_sequence_container::reserve(const size_type sz) {
  */
 [[nodiscard]] inline meta_sequence_container::iterator meta_sequence_container::end() {
     iterator it{};
-    vtable(operation::end, *ctx, std::as_const(storage).data(), storage.policy() == any_policy::cref ? nullptr : this, &it);
+    const void *data = std::as_const(storage).data();
+    vtable(operation::end, *ctx, data, storage.policy() == any_policy::cref ? nullptr : const_cast<void *>(data), &it);
     return it;
 }
 
@@ -1995,20 +1999,23 @@ inline bool meta_associative_container::clear() {
 
 /*! @copydoc meta_sequence_container::reserve */
 inline bool meta_associative_container::reserve(const size_type sz) {
-    return (storage.policy() != any_policy::cref) && vtable(operation::reserve, *ctx, storage.data(), nullptr, &sz, nullptr);
+    auto local = sz;
+    return (storage.policy() != any_policy::cref) && vtable(operation::reserve, *ctx, storage.data(), nullptr, &local, nullptr);
 }
 
 /*! @copydoc meta_sequence_container::begin */
 [[nodiscard]] inline meta_associative_container::iterator meta_associative_container::begin() {
     iterator it{};
-    vtable(operation::begin, *ctx, std::as_const(storage).data(), nullptr, storage.policy() == any_policy::cref ? nullptr : this, &it);
+    const void *data = std::as_const(storage).data();
+    vtable(operation::begin, *ctx, data, nullptr, storage.policy() == any_policy::cref ? nullptr : const_cast<void *>(data), &it);
     return it;
 }
 
 /*! @copydoc meta_sequence_container::end */
 [[nodiscard]] inline meta_associative_container::iterator meta_associative_container::end() {
     iterator it{};
-    vtable(operation::end, *ctx, std::as_const(storage).data(), nullptr, storage.policy() == any_policy::cref ? nullptr : this, &it);
+    const void *data = std::as_const(storage).data();
+    vtable(operation::end, *ctx, data, nullptr, storage.policy() == any_policy::cref ? nullptr : const_cast<void *>(data), &it);
     return it;
 }
 
@@ -2038,7 +2045,8 @@ 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{};
-    vtable(operation::find, *ctx, std::as_const(storage).data(), &key, storage.policy() == any_policy::cref ? nullptr : this, &it);
+    const void *data = std::as_const(storage).data();
+    vtable(operation::find, *ctx, data, &key, storage.policy() == any_policy::cref ? nullptr : const_cast<void *>(data), &it);
     return it;
 }