meta: added operator-> to meta containers' iterators

src/entt/meta/meta.hpp

@@ -9,6 +9,7 @@
 #include "../config/config.h"
 #include "../core/any.hpp"
 #include "../core/fwd.hpp"
+#include "../core/iterator.hpp"
 #include "../core/type_info.hpp"
 #include "../core/type_traits.hpp"
 #include "../core/utility.hpp"
@@ -1479,7 +1480,7 @@ public:
     /*! @brief Type of elements returned by the iterator. */
     using value_type = meta_any;
     /*! @brief Pointer type, `void` on purpose. */
-    using pointer = void;
+    using pointer = input_iterator_proxy<value_type>;
     /*! @brief Reference type, it is **not** an actual reference. */
     using reference = value_type;
     /*! @brief Iterator category. */
@@ -1528,7 +1529,7 @@ public:
     }
 
     /**
-     * @brief Indirection operator.
+     * @brief Indirection operator for accessing the pointed opaque object.
      * @return The element to which the iterator points.
      */
     [[nodiscard]] reference operator*() const {
@@ -1537,6 +1538,14 @@ public:
         return other;
     }
 
+    /**
+     * @brief Access operator for accessing the pointed opaque object.
+     * @return The element to which the iterator points.
+     */
+    [[nodiscard]] pointer operator->() ENTT_NOEXCEPT {
+        return operator*();
+    }
+
     /**
      * @brief Returns false if an iterator is invalid, true otherwise.
      * @return False if the iterator is invalid, true otherwise.
@@ -1677,7 +1686,7 @@ public:
     /*! @brief Type of elements returned by the iterator. */
     using value_type = std::pair<meta_any, meta_any>;
     /*! @brief Pointer type, `void` on purpose. */
-    using pointer = void;
+    using pointer = input_iterator_proxy<value_type>;
     /*! @brief Reference type, it is **not** an actual reference. */
     using reference = value_type;
     /*! @brief Iterator category. */
@@ -1727,7 +1736,7 @@ public:
     }
 
     /**
-     * @brief Indirection operator.
+     * @brief Indirection operator for accessing the pointed opaque object.
      * @return The element to which the iterator points.
      */
     [[nodiscard]] reference operator*() const {
@@ -1736,6 +1745,14 @@ public:
         return other;
     }
 
+    /**
+     * @brief Access operator for accessing the pointed opaque object.
+     * @return The element to which the iterator points.
+     */
+    [[nodiscard]] pointer operator->() ENTT_NOEXCEPT {
+        return operator*();
+    }
+
     /**
      * @brief Returns false if an iterator is invalid, true otherwise.
      * @return False if the iterator is invalid, true otherwise.

test/entt/meta/meta_container.cpp

@@ -71,8 +71,8 @@ TEST_F(MetaContainer, SequenceContainerIterator) {
     ASSERT_TRUE(first != last);
 
     ASSERT_NE(first, last);
-    ASSERT_EQ((*(first++)).cast<int>(), 2);
-    ASSERT_EQ((*(++first)).cast<int>(), 4);
+    ASSERT_EQ((first++)->cast<int>(), 2);
+    ASSERT_EQ((++first)->cast<int>(), 4);
     ASSERT_NE(first++, last);
     ASSERT_EQ(first, last);
 
@@ -98,8 +98,8 @@ TEST_F(MetaContainer, AssociativeContainerIterator) {
     ASSERT_TRUE(first != last);
 
     ASSERT_NE(first, last);
-    ASSERT_EQ((*(first++)).first.cast<int>(), 2);
-    ASSERT_EQ((*(++first)).second.cast<char>(), 'e');
+    ASSERT_EQ((first++)->first.cast<int>(), 2);
+    ASSERT_EQ((++first)->second.cast<char>(), 'e');
     ASSERT_NE(first++, last);
     ASSERT_EQ(first, last);
 
@@ -136,15 +136,15 @@ TEST_F(MetaContainer, StdVector) {
     ASSERT_TRUE(view.insert(++ret, 1.));
 
     ASSERT_EQ(view.size(), 5u);
-    ASSERT_EQ((*view.begin()).cast<int>(), 0);
-    ASSERT_EQ((*++view.begin()).cast<int>(), 1);
+    ASSERT_EQ(view.begin()->cast<int>(), 0);
+    ASSERT_EQ((++view.begin())->cast<int>(), 1);
 
     it = view.begin();
     ret = view.erase(it);
 
     ASSERT_TRUE(ret);
     ASSERT_EQ(view.size(), 4u);
-    ASSERT_EQ((*ret).cast<int>(), 1);
+    ASSERT_EQ(ret->cast<int>(), 1);
 
     ASSERT_TRUE(view.clear());
     ASSERT_EQ(view.size(), 0u);
@@ -178,15 +178,15 @@ TEST_F(MetaContainer, StdArray) {
     ASSERT_FALSE(view.insert(++it, 1.));
 
     ASSERT_EQ(view.size(), 3u);
-    ASSERT_EQ((*view.begin()).cast<int>(), 2);
-    ASSERT_EQ((*++view.begin()).cast<int>(), 3);
+    ASSERT_EQ(view.begin()->cast<int>(), 2);
+    ASSERT_EQ((++view.begin())->cast<int>(), 3);
 
     it = view.begin();
     ret = view.erase(it);
 
     ASSERT_FALSE(ret);
     ASSERT_EQ(view.size(), 3u);
-    ASSERT_EQ((*it).cast<int>(), 2);
+    ASSERT_EQ(it->cast<int>(), 2);
 
     ASSERT_FALSE(view.clear());
     ASSERT_EQ(view.size(), 3u);
@@ -207,7 +207,7 @@ TEST_F(MetaContainer, StdMap) {
     ASSERT_EQ(view.size(), 3u);
     ASSERT_NE(view.begin(), view.end());
 
-    ASSERT_EQ((*view.find(3)).second.cast<char>(), 'd');
+    ASSERT_EQ(view.find(3)->second.cast<char>(), 'd');
 
     ASSERT_FALSE(view.insert(invalid_type{}, 'a'));
     ASSERT_FALSE(view.insert(1, invalid_type{}));
@@ -216,8 +216,8 @@ TEST_F(MetaContainer, StdMap) {
     ASSERT_TRUE(view.insert(1., static_cast<int>('b')));
 
     ASSERT_EQ(view.size(), 5u);
-    ASSERT_EQ((*view.find(0)).second.cast<char>(), 'a');
-    ASSERT_EQ((*view.find(1.)).second.cast<char>(), 'b');
+    ASSERT_EQ(view.find(0)->second.cast<char>(), 'a');
+    ASSERT_EQ(view.find(1.)->second.cast<char>(), 'b');
 
     ASSERT_FALSE(view.erase(invalid_type{}));
     ASSERT_FALSE(view.find(invalid_type{}));
@@ -227,9 +227,9 @@ TEST_F(MetaContainer, StdMap) {
     ASSERT_EQ(view.size(), 4u);
     ASSERT_EQ(view.find(0), view.end());
 
-    (*view.find(1.)).second.cast<char &>() = 'f';
+    view.find(1.)->second.cast<char &>() = 'f';
 
-    ASSERT_EQ((*view.find(1.f)).second.cast<char>(), 'f');
+    ASSERT_EQ(view.find(1.f)->second.cast<char>(), 'f');
 
     ASSERT_TRUE(view.erase(1.));
     ASSERT_TRUE(view.clear());
@@ -251,7 +251,7 @@ TEST_F(MetaContainer, StdSet) {
     ASSERT_EQ(view.size(), 3u);
     ASSERT_NE(view.begin(), view.end());
 
-    ASSERT_EQ((*view.find(3)).first.cast<int>(), 3);
+    ASSERT_EQ(view.find(3)->first.cast<int>(), 3);
 
     ASSERT_FALSE(view.insert(invalid_type{}));
 
@@ -259,8 +259,8 @@ TEST_F(MetaContainer, StdSet) {
     ASSERT_TRUE(view.insert(1));
 
     ASSERT_EQ(view.size(), 5u);
-    ASSERT_EQ((*view.find(0)).first.cast<int>(), 0);
-    ASSERT_EQ((*view.find(1.)).first.cast<int>(), 1);
+    ASSERT_EQ(view.find(0)->first.cast<int>(), 0);
+    ASSERT_EQ(view.find(1.)->first.cast<int>(), 1);
 
     ASSERT_FALSE(view.erase(invalid_type{}));
     ASSERT_FALSE(view.find(invalid_type{}));
@@ -270,9 +270,9 @@ TEST_F(MetaContainer, StdSet) {
     ASSERT_EQ(view.size(), 4u);
     ASSERT_EQ(view.find(0), view.end());
 
-    ASSERT_EQ((*view.find(1.f)).first.try_cast<int>(), nullptr);
-    ASSERT_NE((*view.find(1.)).first.try_cast<const int>(), nullptr);
-    ASSERT_EQ((*view.find(true)).first.cast<const int &>(), 1);
+    ASSERT_EQ(view.find(1.f)->first.try_cast<int>(), nullptr);
+    ASSERT_NE(view.find(1.)->first.try_cast<const int>(), nullptr);
+    ASSERT_EQ(view.find(true)->first.cast<const int &>(), 1);
 
     ASSERT_TRUE(view.erase(1.));
     ASSERT_TRUE(view.clear());
@@ -307,7 +307,7 @@ TEST_F(MetaContainer, ConstSequenceContainer) {
 
     ASSERT_FALSE(ret);
     ASSERT_EQ(view.size(), 1u);
-    ASSERT_EQ((*it).cast<int>(), 42);
+    ASSERT_EQ(it->cast<int>(), 42);
     ASSERT_EQ(++it, view.end());
 
     it = view.begin();
@@ -340,13 +340,13 @@ TEST_F(MetaContainer, ConstKeyValueAssociativeContainer) {
     ASSERT_EQ(view.size(), 1u);
     ASSERT_NE(view.begin(), view.end());
 
-    ASSERT_DEATH((*view.find(2)).second.cast<char &>() = 'a', "");
-    ASSERT_EQ((*view.find(2)).second.cast<const char &>(), 'c');
+    ASSERT_DEATH(view.find(2)->second.cast<char &>() = 'a', "");
+    ASSERT_EQ(view.find(2)->second.cast<const char &>(), 'c');
 
     ASSERT_FALSE(view.insert(0, 'a'));
     ASSERT_EQ(view.size(), 1u);
     ASSERT_EQ(view.find(0), view.end());
-    ASSERT_EQ((*view.find(2)).second.cast<char>(), 'c');
+    ASSERT_EQ(view.find(2)->second.cast<char>(), 'c');
 
     ASSERT_FALSE(view.erase(2));
     ASSERT_EQ(view.size(), 1u);
@@ -376,15 +376,15 @@ TEST_F(MetaContainer, ConstKeyOnlyAssociativeContainer) {
     ASSERT_EQ(view.size(), 1u);
     ASSERT_NE(view.begin(), view.end());
 
-    ASSERT_EQ((*view.find(2)).first.try_cast<int>(), nullptr);
-    ASSERT_NE((*view.find(2)).first.try_cast<const int>(), nullptr);
-    ASSERT_EQ((*view.find(2)).first.cast<int>(), 2);
-    ASSERT_EQ((*view.find(2)).first.cast<const int &>(), 2);
+    ASSERT_EQ(view.find(2)->first.try_cast<int>(), nullptr);
+    ASSERT_NE(view.find(2)->first.try_cast<const int>(), nullptr);
+    ASSERT_EQ(view.find(2)->first.cast<int>(), 2);
+    ASSERT_EQ(view.find(2)->first.cast<const int &>(), 2);
 
     ASSERT_FALSE(view.insert(0));
     ASSERT_EQ(view.size(), 1u);
     ASSERT_EQ(view.find(0), view.end());
-    ASSERT_EQ((*view.find(2)).first.cast<int>(), 2);
+    ASSERT_EQ(view.find(2)->first.cast<int>(), 2);
 
     ASSERT_FALSE(view.erase(2));
     ASSERT_EQ(view.size(), 1u);
@@ -417,8 +417,8 @@ TEST_F(MetaContainer, KeyValueAssociativeContainerConstMetaAny) {
 
         ASSERT_TRUE(view);
         ASSERT_EQ(view.value_type(), (entt::resolve<std::pair<const int, char>>()));
-        ASSERT_DEATH((*view.find(2)).second.cast<char &>() = 'a', "");
-        ASSERT_EQ((*view.find(2)).second.cast<const char &>(), 'c');
+        ASSERT_DEATH(view.find(2)->second.cast<char &>() = 'a', "");
+        ASSERT_EQ(view.find(2)->second.cast<const char &>(), 'c');
     };
 
     std::map<int, char> map{{2, 'c'}};
@@ -435,10 +435,10 @@ TEST_F(MetaContainer, KeyOnlyAssociativeContainerConstMetaAny) {
         ASSERT_TRUE(view);
         ASSERT_EQ(view.value_type(), (entt::resolve<int>()));
 
-        ASSERT_EQ((*view.find(2)).first.try_cast<int>(), nullptr);
-        ASSERT_NE((*view.find(2)).first.try_cast<const int>(), nullptr);
-        ASSERT_EQ((*view.find(2)).first.cast<int>(), 2);
-        ASSERT_EQ((*view.find(2)).first.cast<const int &>(), 2);
+        ASSERT_EQ(view.find(2)->first.try_cast<int>(), nullptr);
+        ASSERT_NE(view.find(2)->first.try_cast<const int>(), nullptr);
+        ASSERT_EQ(view.find(2)->first.cast<int>(), 2);
+        ASSERT_EQ(view.find(2)->first.cast<const int &>(), 2);
     };
 
     std::set<int> set{2};
@@ -482,15 +482,15 @@ TEST_F(MetaContainer, StdVectorBool) {
     ASSERT_TRUE(view.insert(++ret, false));
 
     ASSERT_EQ(view.size(), 5u);
-    ASSERT_EQ((*view.begin()).cast<proxy_type>(), true);
-    ASSERT_EQ((*++cview.begin()).cast<const_proxy_type>(), false);
+    ASSERT_EQ(view.begin()->cast<proxy_type>(), true);
+    ASSERT_EQ((++cview.begin())->cast<const_proxy_type>(), false);
 
     it = view.begin();
     ret = view.erase(it);
 
     ASSERT_TRUE(ret);
     ASSERT_EQ(view.size(), 4u);
-    ASSERT_EQ((*ret).cast<proxy_type>(), false);
+    ASSERT_EQ(ret->cast<proxy_type>(), false);
 
     ASSERT_TRUE(view.clear());
     ASSERT_EQ(cview.size(), 0u);