Fix: Dereferencing member_iterator_t

Author: ashvardanian

cpp/test.cpp

@@ -58,20 +58,20 @@ template <typename index_at> struct aligned_wrapper_gt {
 };
 
 /**
- * Tests the functionality of the custom uint40_t type ensuring consistent 
+ * Tests the functionality of the custom uint40_t type ensuring consistent
  * behavior across various constructors from uint32_t, uint64_t, and size_t types.
  */
 void test_uint40() {
     // Constants for tests
     std::uint64_t max_uint40_k = (1ULL << 40) - 1;
 
     for (std::uint64_t original_value : {
-        42ull,                        // Typical small number
-        4242ull,                      // Larger number still within uint40 range
-        1ull << 40,                   // Exactly at the boundary of uint40
-        (1ull << 40) + 1,             // Just beyond the boundary of uint40
-        1ull << 63                    // Well beyond the uint40 boundary, tests masking
-    }) {
+             42ull,            // Typical small number
+             4242ull,          // Larger number still within uint40 range
+             1ull << 40,       // Exactly at the boundary of uint40
+             (1ull << 40) + 1, // Just beyond the boundary of uint40
+             1ull << 63        // Well beyond the uint40 boundary, tests masking
+         }) {
         std::uint32_t v_32 = static_cast<std::uint32_t>(original_value);
         std::uint64_t v_64 = original_value;
         std::size_t v_size = static_cast<std::size_t>(original_value);
@@ -742,10 +742,10 @@ template <typename key_at, typename slot_at> void test_strings() {
             return between(some_vector, str_at(get_slot(member)));
         }
         levenshtein_distance_t operator()(member_citerator_t const& a, member_citerator_t const& b) const {
-            return between(str_at(get_slot(b)), str_at(get_slot(a)));
+            return between(str_at(get_slot(*b)), str_at(get_slot(*a)));
         }
         levenshtein_distance_t operator()(std::string_view some_vector, member_citerator_t const& member) const {
-            return between(some_vector, str_at(get_slot(member)));
+            return between(some_vector, str_at(get_slot(*member)));
         }
     };
 

include/usearch/index.hpp

@@ -1749,6 +1749,9 @@ class index_gt {
         member_iterator_gt() noexcept {}
         member_iterator_gt(index_t* index, std::size_t slot) noexcept : index_(index), slot_(slot) {}
 
+        ref_t call_key(std::true_type) const noexcept { return ref_t{index_->node_at_(slot_).ckey(), slot_}; }
+        ref_t call_key(std::false_type) const noexcept { return ref_t{index_->node_at_(slot_).key(), slot_}; }
+
         index_t* index_{};
         std::size_t slot_{};
 
@@ -1759,8 +1762,8 @@ class index_gt {
         using pointer = void;
         using reference = ref_t;
 
-        reference operator*() const noexcept { return {index_->node_at_(slot_).key(), slot_}; }
-        vector_key_t key() const noexcept { return index_->node_at_(slot_).key(); }
+        reference operator*() const noexcept { return call_key(std::is_const<index_t>()); }
+        vector_key_t key() const noexcept { return index_->node_at_(slot_).ckey(); }
 
         friend inline std::size_t get_slot(member_iterator_gt const& it) noexcept { return it.slot_; }
         friend inline vector_key_t get_key(member_iterator_gt const& it) noexcept { return it.key(); }
@@ -1865,8 +1868,10 @@ class index_gt {
         node_t& operator=(node_t const&) = default;
 
         misaligned_ref_gt<vector_key_t const> ckey() const noexcept { return {tape_}; }
-        misaligned_ref_gt<vector_key_t> key() const noexcept { return {tape_}; }
-        misaligned_ref_gt<level_t> level() const noexcept { return {tape_ + sizeof(vector_key_t)}; }
+        misaligned_ref_gt<vector_key_t const> ckey() noexcept { return {tape_}; }
+        misaligned_ref_gt<vector_key_t const> key() const noexcept { return {tape_}; }
+        misaligned_ref_gt<vector_key_t> key() noexcept { return {tape_}; }
+        misaligned_ref_gt<level_t> level() noexcept { return {tape_ + sizeof(vector_key_t)}; }
 
         void key(vector_key_t v) noexcept { return misaligned_store<vector_key_t>(tape_, v); }
         void level(level_t v) noexcept { return misaligned_store<level_t>(tape_ + sizeof(vector_key_t), v); }