Canonicalize char[N] and string_view keys in KeyParam and raw_hash_map. Convert 1D char[N] and absl::string_view keys to absl::string_view before try_emplace_impl, insert_or_assign_impl, and KeyParam on StringHash/StringEq tables. PiperOrigin-RevId: 1024778963
diff --git a/absl/container/internal/raw_hash_map.h b/absl/container/internal/raw_hash_map.h index b85accf..94e25e0 100644 --- a/absl/container/internal/raw_hash_map.h +++ b/absl/container/internal/raw_hash_map.h
@@ -155,7 +155,10 @@ ABSL_ATTRIBUTE_LIFETIME_BOUND { \ return ABSL_INTERNAL_IF_##KValue##_OR_##VValue( \ (this->template Func<K, V, 0>), Callee)( \ - std::forward<decltype(k)>(k), std::forward<decltype(v)>(v)) Tail; \ + ABSL_INTERNAL_IF_##KValue##_OR_##VValue( \ + std::forward<decltype(k)>(k), \ + this->CanonicalizeKey(std::forward<decltype(k)>(k))), \ + std::forward<decltype(v)>(v)) Tail; \ } \ static_assert(true, "This is to force a semicolon.") @@ -242,7 +245,7 @@ std::enable_if_t<!std::is_convertible_v<K, const_iterator>, int> = 0> std::pair<iterator, bool> try_emplace(key_arg<K>&& k, Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND { - return try_emplace_impl(std::forward<key_arg<K>>(k), + return try_emplace_impl(this->CanonicalizeKey(std::forward<key_arg<K>>(k)), std::forward<Args>(args)...); } @@ -263,7 +266,8 @@ std::enable_if_t<!std::is_convertible_v<K, const_iterator>, int> = 0> std::pair<iterator, bool> try_emplace(const key_arg<K>& k, Args&&... args) ABSL_ATTRIBUTE_LIFETIME_BOUND { - return try_emplace_impl(k, std::forward<Args>(args)...); + return try_emplace_impl(this->CanonicalizeKey(k), + std::forward<Args>(args)...); } template < class K = key_type, class... Args, EnableIf<LifetimeBoundK<K, true>> = 0,
diff --git a/absl/container/internal/raw_hash_set.h b/absl/container/internal/raw_hash_set.h index 6ee6d3e..5844e5a 100644 --- a/absl/container/internal/raw_hash_set.h +++ b/absl/container/internal/raw_hash_set.h
@@ -4367,9 +4367,39 @@ } protected: + static constexpr bool kIsStringAbslHashEq = + std::is_same_v<hasher, absl::container_internal::StringHash> && + std::is_same_v<key_equal, absl::container_internal::StringEq>; + + template <class T> + struct IsCharArray : std::false_type {}; + template <size_t N> + struct IsCharArray<char[N]> : std::true_type {}; + template <size_t N> + struct IsCharArray<const char[N]> : std::true_type {}; + + // Collapse char[N] keys of different lengths to absl::string_view to avoid + // per-length instantiations and repeated strlen calls. + template <class K, class RemoveCvrefK = absl::remove_cvref_t<K>> + using CanonicalKey = std::conditional_t<kIsStringAbslHashEq && + IsCharArray<RemoveCvrefK>::value, + absl::string_view, RemoveCvrefK>; + template <class K> - using KeyParam = type_traits_internal::AddConstRefIfExpensiveToCopy< - absl::remove_cvref_t<K>>; + using KeyParam = + type_traits_internal::AddConstRefIfExpensiveToCopy<CanonicalKey<K>>; + + template <class K> + static decltype(auto) CanonicalizeKey(K&& k) { + if constexpr (std::conjunction_v< + std::bool_constant<kIsStringAbslHashEq>, + std::is_same<CanonicalKey<K>, absl::string_view>, + std::is_constructible<key_type, absl::string_view>>) { + return absl::string_view(k); + } else { + return std::forward<K>(k); + } + } // Asserts for correctness that we run on find/find_or_prepare_insert. template <class K> @@ -4395,9 +4425,6 @@ // validation. This improves debug performance, but also is important for // correctness of the *ConversionCount tests, which fail if we call hash/eq // on the lookup keys extra times (which triggers additional conversions). - constexpr bool kIsStringAbslHashEq = - std::is_same_v<hasher, absl::container_internal::StringHash> && - std::is_same_v<key_equal, absl::container_internal::StringEq>; constexpr bool kIsScalarAbslHashEq = std::is_scalar_v<key_type> && std::is_same_v<hasher, typename HashEq<key_type>::Hash> && @@ -4493,8 +4520,7 @@ // explicitly.) template <class K, class RemoveCvrefK = absl::remove_cvref_t<K>, bool IsStringHashEqAndConvertibleToStringView = - std::is_same_v<hasher, absl::container_internal::StringHash> && - std::is_same_v<key_equal, absl::container_internal::StringEq> && + kIsStringAbslHashEq && std::is_convertible_v<const RemoveCvrefK&, absl::string_view>, class Ptr = std::remove_pointer_t<key_type>*, class ConstPtr = const std::remove_pointer_t<key_type>*,
diff --git a/absl/container/internal/raw_hash_set_test.cc b/absl/container/internal/raw_hash_set_test.cc index 970420e..280a4a4 100644 --- a/absl/container/internal/raw_hash_set_test.cc +++ b/absl/container/internal/raw_hash_set_test.cc
@@ -79,6 +79,8 @@ namespace container_internal { struct RawHashSetTestOnlyAccess { + template <typename C, typename K> + using KeyParam = typename C::raw_hash_set::template KeyParam<K>; template <typename C> static auto GetCommon(C&& c) -> decltype(std::forward<C>(c).common()) { return std::forward<C>(c).common(); @@ -3205,6 +3207,48 @@ EXPECT_EQ(*m[1], 42); } +TEST(Table, CharArrayKeyParamCanonicalizesToStringView) { + using StringMap = absl::flat_hash_map<std::string, int>; + EXPECT_TRUE((std::is_same_v< + RawHashSetTestOnlyAccess::KeyParam<StringMap, const char (&)[4]>, + absl::string_view>)); + EXPECT_TRUE((std::is_same_v< + RawHashSetTestOnlyAccess::KeyParam<StringMap, char (&)[64]>, + absl::string_view>)); + + StringMap m = {{"abc", 1}}; + char buf[64] = "abc\0xyz"; + EXPECT_EQ(m.find("abc")->second, 1); + EXPECT_EQ(m.find(buf)->second, 1); + EXPECT_FALSE(m.try_emplace(buf, 2).second); + EXPECT_FALSE(m.emplace(buf, 2).second); + EXPECT_FALSE(m.insert_or_assign(buf, 3).second); + EXPECT_EQ(m["abc"], 3); + + // Exercise a string key with a non-default-constructible allocator. + using AllocString = + std::basic_string<char, std::char_traits<char>, FreezableAlloc<char>>; + bool frozen = false; + FreezableAlloc<char> alloc(&frozen); + absl::flat_hash_map<AllocString, int, absl::container_internal::StringHash, + absl::container_internal::StringEq, + FreezableAlloc<std::pair<const AllocString, int>>> + alloc_map{FreezableAlloc<std::pair<const AllocString, int>>(alloc)}; + alloc_map[AllocString("abc", alloc)] = 1; + EXPECT_EQ(alloc_map.at("abc"), 1); + + struct CStrOnlyKey { + std::string s; + CStrOnlyKey(const char* p) : s(p) {} // NOLINT + CStrOnlyKey(absl::string_view) = delete; + operator absl::string_view() const { return s; } // NOLINT + }; + absl::flat_hash_map<CStrOnlyKey, int, absl::container_internal::StringHash, + absl::container_internal::StringEq> + cstr_map; + cstr_map["abc"] = 1; + EXPECT_EQ(cstr_map.at("abc"), 1); +} TEST(Table, DecomposeRangeInsert) { if (SwisstableGenerationsEnabled()) { GTEST_SKIP() << "Generations being enabled causes extra rehashes.";