meta: get rid of useless boolean values in the return types of meta containers

src/entt/meta/container.hpp

@@ -49,20 +49,24 @@ struct basic_meta_sequence_container_traits {
 
     [[nodiscard]] static bool resize(any &container, size_type sz) {
         if constexpr(is_dynamic_sequence_container<Type>::value) {
-            auto * const cont = any_cast<Type>(&container);
-            return cont && (cont->resize(sz), true);
-        } else {
-            return false;
+            if(auto * const cont = any_cast<Type>(&container); cont) {
+                cont->resize(sz);
+                return true;
+            }
         }
+
+        return false;
     }
 
     [[nodiscard]] static bool clear(any &container) {
         if constexpr(is_dynamic_sequence_container<Type>::value) {
-            auto * const cont = any_cast<Type>(&container);
-            return cont && (cont->clear(), true);
-        } else {
-            return false;
+            if(auto * const cont = any_cast<Type>(&container); cont) {
+                cont->clear();
+                return true;
+            }
         }
+
+        return false;
     }
 
     [[nodiscard]] static iterator begin(any &container) {
@@ -81,13 +85,13 @@ struct basic_meta_sequence_container_traits {
         return iterator{any_cast<const Type &>(container).end()};
     }
 
-    [[nodiscard]] static std::pair<iterator, bool> insert(any &container, iterator it, meta_any &value) {
+    [[nodiscard]] static iterator insert(any &container, iterator it, meta_any &value) {
         if constexpr(is_dynamic_sequence_container<Type>::value) {
             if(auto * const cont = any_cast<Type>(&container); cont) {
                 // this abomination is necessary because only on macos value_type and const_reference are different types for std::vector<bool>
                 if(value.allow_cast<typename Type::const_reference>() || value.allow_cast<typename Type::value_type>()) {
                     const auto *element = value.try_cast<std::remove_reference_t<typename Type::const_reference>>();
-                    return { iterator{cont->insert(any_cast<const typename Type::iterator &>(it.base()), element ? *element : value.cast<typename Type::value_type>())}, true };
+                    return iterator{cont->insert(any_cast<const typename Type::iterator &>(it.base()), element ? *element : value.cast<typename Type::value_type>())};
                 }
             }
         }
@@ -95,10 +99,10 @@ struct basic_meta_sequence_container_traits {
         return {};
     }
 
-    [[nodiscard]] static std::pair<iterator, bool> erase(any &container, iterator it) {
+    [[nodiscard]] static iterator erase(any &container, iterator it) {
         if constexpr(is_dynamic_sequence_container<Type>::value) {
             if(auto * const cont = any_cast<Type>(&container); cont) {
-                return { iterator{cont->erase(any_cast<const typename Type::iterator &>(it.base()))}, true };
+                return iterator{cont->erase(any_cast<const typename Type::iterator &>(it.base()))};
             }
         }
 
@@ -155,7 +159,7 @@ struct basic_meta_associative_container_traits {
                 return cont->insert(key.cast<const typename Type::key_type &>()).second;
             } else {
                 return value.allow_cast<const typename Type::mapped_type &>()
-                    && cont->insert(std::make_pair(key.cast<const typename Type::key_type &>(), value.cast<const typename Type::mapped_type &>())).second;
+                    && cont->emplace(key.cast<const typename Type::key_type &>(), value.cast<const typename Type::mapped_type &>()).second;
             }
         }
 

src/entt/meta/meta.hpp

@@ -66,8 +66,8 @@ public:
     inline bool clear();
     [[nodiscard]] inline iterator begin();
     [[nodiscard]] inline iterator end();
-    inline std::pair<iterator, bool> insert(iterator, meta_any);
-    inline std::pair<iterator, bool> erase(iterator);
+    inline iterator insert(iterator, meta_any);
+    inline iterator erase(iterator);
     [[nodiscard]] inline meta_any operator[](size_type);
     [[nodiscard]] inline explicit operator bool() const ENTT_NOEXCEPT;
 
@@ -78,8 +78,8 @@ private:
     bool(* clear_fn)(any &) = nullptr;
     iterator(* begin_fn)(any &) = nullptr;
     iterator(* end_fn)(any &) = nullptr;
-    std::pair<iterator, bool>(* insert_fn)(any &, iterator, meta_any &) = nullptr;
-    std::pair<iterator, bool>(* erase_fn)(any &, iterator) = nullptr;
+    iterator(* insert_fn)(any &, iterator, meta_any &) = nullptr;
+    iterator(* erase_fn)(any &, iterator) = nullptr;
     meta_any(* get_fn)(any &, size_type) = nullptr;
     any storage{};
 };
@@ -1838,10 +1838,9 @@ inline bool meta_sequence_container::clear() {
  * @brief Inserts an element at a specified location of a container.
  * @param it Iterator before which the element will be inserted.
  * @param value Element value to insert.
- * @return A pair consisting of an iterator to the inserted element (in case of
- * success) and a bool denoting whether the insertion took place.
+ * @return A possibly invalid iterator to the inserted element.
  */
-inline std::pair<meta_sequence_container::iterator, bool> meta_sequence_container::insert(iterator it, meta_any value) {
+inline meta_sequence_container::iterator meta_sequence_container::insert(iterator it, meta_any value) {
     return insert_fn(storage, it, value);
 }
 
@@ -1849,10 +1848,9 @@ inline std::pair<meta_sequence_container::iterator, bool> meta_sequence_containe
 /**
  * @brief Removes a given element from a container.
  * @param it Iterator to the element to remove.
- * @return A pair consisting of an iterator following the last removed element
- * (in case of success) and a bool denoting whether the deletion took place.
+ * @return A possibly invalid iterator following the last removed element.
  */
-inline std::pair<meta_sequence_container::iterator, bool> meta_sequence_container::erase(iterator it) {
+inline meta_sequence_container::iterator meta_sequence_container::erase(iterator it) {
     return erase_fn(storage, it);
 }
 

test/entt/meta/meta_container.cpp

@@ -133,9 +133,9 @@ TEST_F(MetaContainer, StdVector) {
     auto it = view.begin();
     auto ret = view.insert(it, 0);
 
-    ASSERT_TRUE(ret.second);
-    ASSERT_FALSE(view.insert(ret.first, 'c').second);
-    ASSERT_TRUE(view.insert(++ret.first, 1.).second);
+    ASSERT_TRUE(ret);
+    ASSERT_FALSE(view.insert(ret, 'c'));
+    ASSERT_TRUE(view.insert(++ret, 1.));
 
     ASSERT_EQ(view.size(), 5u);
     ASSERT_EQ((*view.begin()).cast<int>(), 0);
@@ -144,9 +144,9 @@ TEST_F(MetaContainer, StdVector) {
     it = view.begin();
     ret = view.erase(it);
 
-    ASSERT_TRUE(ret.second);
+    ASSERT_TRUE(ret);
     ASSERT_EQ(view.size(), 4u);
-    ASSERT_EQ((*ret.first).cast<int>(), 1);
+    ASSERT_EQ((*ret).cast<int>(), 1);
 
     ASSERT_TRUE(view.clear());
     ASSERT_EQ(view.size(), 0u);
@@ -175,9 +175,9 @@ TEST_F(MetaContainer, StdArray) {
     auto it = view.begin();
     auto ret = view.insert(it, 0);
 
-    ASSERT_FALSE(ret.second);
-    ASSERT_FALSE(view.insert(it, 'c').second);
-    ASSERT_FALSE(view.insert(++it, 1).second);
+    ASSERT_FALSE(ret);
+    ASSERT_FALSE(view.insert(it, 'c'));
+    ASSERT_FALSE(view.insert(++it, 1));
 
     ASSERT_EQ(view.size(), 3u);
     ASSERT_EQ((*view.begin()).cast<int>(), 2);
@@ -186,7 +186,7 @@ TEST_F(MetaContainer, StdArray) {
     it = view.begin();
     ret = view.erase(it);
 
-    ASSERT_FALSE(ret.second);
+    ASSERT_FALSE(ret);
     ASSERT_EQ(view.size(), 3u);
     ASSERT_EQ((*it).cast<int>(), 2);
 
@@ -307,7 +307,7 @@ TEST_F(MetaContainer, ConstSequenceContainer) {
     auto it = view.begin();
     auto ret = view.insert(it, 0);
 
-    ASSERT_FALSE(ret.second);
+    ASSERT_FALSE(ret);
     ASSERT_EQ(view.size(), 1u);
     ASSERT_EQ((*it).cast<int>(), 42);
     ASSERT_EQ(++it, view.end());
@@ -315,7 +315,7 @@ TEST_F(MetaContainer, ConstSequenceContainer) {
     it = view.begin();
     ret = view.erase(it);
 
-    ASSERT_FALSE(ret.second);
+    ASSERT_FALSE(ret);
     ASSERT_EQ(view.size(), 1u);
 
     ASSERT_FALSE(view.clear());
@@ -479,9 +479,9 @@ TEST_F(MetaContainer, StdVectorBool) {
     auto it = view.begin();
     auto ret = view.insert(it, true);
 
-    ASSERT_TRUE(ret.second);
-    ASSERT_FALSE(view.insert(ret.first, 'c').second);
-    ASSERT_TRUE(view.insert(++ret.first, false).second);
+    ASSERT_TRUE(ret);
+    ASSERT_FALSE(view.insert(ret, 'c'));
+    ASSERT_TRUE(view.insert(++ret, false));
 
     ASSERT_EQ(view.size(), 5u);
     ASSERT_EQ((*view.begin()).cast<proxy_type>(), true);
@@ -490,9 +490,9 @@ TEST_F(MetaContainer, StdVectorBool) {
     it = view.begin();
     ret = view.erase(it);
 
-    ASSERT_TRUE(ret.second);
+    ASSERT_TRUE(ret);
     ASSERT_EQ(view.size(), 4u);
-    ASSERT_EQ((*ret.first).cast<proxy_type>(), false);
+    ASSERT_EQ((*ret).cast<proxy_type>(), false);
 
     ASSERT_TRUE(view.clear());
     ASSERT_EQ(cview.size(), 0u);