fix const value return by emplace iterator

include/tsl/sparse_hash.h

@@ -993,7 +993,7 @@ class sparse_array {
 template <class ValueType, class KeySelect, class ValueSelect, class Hash,
           class KeyEqual, class Allocator, class GrowthPolicy,
           tsl::sh::exception_safety ExceptionSafety, tsl::sh::sparsity Sparsity,
-          tsl::sh::probing Probing>
+          tsl::sh::probing Probing, class ValueTypeIt>
 class sparse_hash : private Allocator,
                     private Hash,
                     private KeyEqual,
@@ -1027,6 +1027,12 @@ class sparse_hash : private Allocator,
   using iterator = sparse_iterator<false>;
   using const_iterator = sparse_iterator<true>;
 
+  using value_type_it = ValueTypeIt;
+  using reference_it = value_type_it &;
+  using const_reference_it = const value_type_it &;
+  using pointer_it = value_type_it *;
+  using const_pointer_it = const value_type_it *;
+
  private:
   using sparse_array =
       tsl::detail_sparse_hash::sparse_array<ValueType, Allocator, Sparsity>;
@@ -1070,10 +1076,16 @@ class sparse_hash : private Allocator,
 
    public:
     using iterator_category = std::forward_iterator_tag;
-    using value_type = const typename sparse_hash::value_type;
+    using value_type = typename sparse_hash::value_type_it;
     using difference_type = std::ptrdiff_t;
-    using reference = value_type &;
-    using pointer = value_type *;
+    using reference =
+        typename std::conditional<IsConst,
+                                  typename sparse_hash::const_reference_it,
+                                  typename sparse_hash::reference_it>::type;
+    using pointer =
+        typename std::conditional<IsConst,
+                                  typename sparse_hash::const_pointer_it,
+                                  typename sparse_hash::pointer_it>::type;
 
     sparse_iterator() noexcept {}
 
@@ -1107,9 +1119,13 @@ class sparse_hash : private Allocator,
       return U()(*m_sparse_array_it);
     }
 
-    reference operator*() const { return *m_sparse_array_it; }
+    reference operator*() const {
+      return reinterpret_cast<reference>(*m_sparse_array_it);
+    }
 
-    pointer operator->() const { return std::addressof(*m_sparse_array_it); }
+    pointer operator->() const {
+      return reinterpret_cast<pointer>(std::addressof(*m_sparse_array_it));
+    }
 
     sparse_iterator &operator++() {
       tsl_sh_assert(m_sparse_array_it != nullptr);

include/tsl/sparse_map.h

@@ -103,6 +103,15 @@ class sparse_map {
     key_type &operator()(std::pair<Key, T> &key_value) noexcept {
       return key_value.first;
     }
+
+    const key_type &operator()(
+        const std::pair<const Key, T> &key_value) const noexcept {
+      return key_value.first;
+    }
+
+    const key_type &operator()(std::pair<const Key, T> &key_value) noexcept {
+      return key_value.first;
+    }
   };
 
   class ValueSelect {
@@ -121,7 +130,8 @@ class sparse_map {
 
   using ht = detail_sparse_hash::sparse_hash<
       std::pair<Key, T>, KeySelect, ValueSelect, Hash, KeyEqual, Allocator,
-      GrowthPolicy, ExceptionSafety, Sparsity, tsl::sh::probing::quadratic>;
+      GrowthPolicy, ExceptionSafety, Sparsity, tsl::sh::probing::quadratic,
+      std::pair<const Key, T>>;
 
  public:
   using key_type = typename ht::key_type;

include/tsl/sparse_set.h

@@ -100,10 +100,9 @@ class sparse_set {
     key_type &operator()(Key &key) noexcept { return key; }
   };
 
-  using ht =
-      detail_sparse_hash::sparse_hash<Key, KeySelect, void, Hash, KeyEqual,
-                                      Allocator, GrowthPolicy, ExceptionSafety,
-                                      Sparsity, tsl::sh::probing::quadratic>;
+  using ht = detail_sparse_hash::sparse_hash<
+      Key, KeySelect, void, Hash, KeyEqual, Allocator, GrowthPolicy,
+      ExceptionSafety, Sparsity, tsl::sh::probing::quadratic, Key>;
 
  public:
   using key_type = typename ht::key_type;