Add type casters for `absl::node_hash_set` and `absl::node_hash_map`.

PiperOrigin-RevId: 512783089

pybind11_abseil/BUILD

@@ -14,6 +14,8 @@ pybind_library(
         "@com_google_absl//absl/container:btree",
         "@com_google_absl//absl/container:btree",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_map",
         "@com_google_absl//absl/container:flat_hash_set",
         "@com_google_absl//absl/container:flat_hash_set",
+        "@com_google_absl//absl/container:node_hash_map",
+        "@com_google_absl//absl/container:node_hash_set",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/strings",
         "@com_google_absl//absl/time",
         "@com_google_absl//absl/time",
         "@com_google_absl//absl/types:optional",
         "@com_google_absl//absl/types:optional",

pybind11_abseil/absl_casters.h

@@ -44,6 +44,8 @@
 #include "absl/container/btree_map.h"
 #include "absl/container/btree_map.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_map.h"
 #include "absl/container/flat_hash_set.h"
 #include "absl/container/flat_hash_set.h"
+#include "absl/container/node_hash_map.h"
+#include "absl/container/node_hash_set.h"
 #include "absl/strings/cord.h"
 #include "absl/strings/cord.h"
 #include "absl/strings/string_view.h"
 #include "absl/strings/string_view.h"
 #include "absl/time/civil_time.h"
 #include "absl/time/civil_time.h"
@@ -412,6 +414,13 @@ struct type_caster<absl::flat_hash_map<Key, Value, Hash, Equal, Alloc>>
     : map_caster<absl::flat_hash_map<Key, Value, Hash, Equal, Alloc>, Key,
     : map_caster<absl::flat_hash_map<Key, Value, Hash, Equal, Alloc>, Key,
                  Value> {};
                  Value> {};
 
 
+// Convert between absl::flat_hash_map and python dict.
+template <typename Key, typename Value, typename Hash, typename Equal,
+          typename Alloc>
+struct type_caster<absl::node_hash_map<Key, Value, Hash, Equal, Alloc>>
+    : map_caster<absl::node_hash_map<Key, Value, Hash, Equal, Alloc>, Key,
+                 Value> {};
+
 // Convert between absl::flat_hash_set and python set.
 // Convert between absl::flat_hash_set and python set.
 template <typename Key, typename Hash, typename Equal, typename Alloc>
 template <typename Key, typename Hash, typename Equal, typename Alloc>
 struct type_caster<absl::flat_hash_set<Key, Hash, Equal, Alloc>>
 struct type_caster<absl::flat_hash_set<Key, Hash, Equal, Alloc>>
@@ -422,6 +431,11 @@ template <typename Key, typename Value, typename Compare, typename Alloc>
 struct type_caster<absl::btree_map<Key, Value, Compare, Alloc>>
 struct type_caster<absl::btree_map<Key, Value, Compare, Alloc>>
     : map_caster<absl::btree_map<Key, Value, Compare, Alloc>, Key, Value> {};
     : map_caster<absl::btree_map<Key, Value, Compare, Alloc>, Key, Value> {};
 
 
+// Convert between absl::node_hash_set and python set.
+template <typename Key, typename Hash, typename Equal, typename Alloc>
+struct type_caster<absl::node_hash_set<Key, Hash, Equal, Alloc>>
+    : set_caster<absl::node_hash_set<Key, Hash, Equal, Alloc>, Key> {};
+
 // Convert between absl::string_view and python.
 // Convert between absl::string_view and python.
 //
 //
 // pybind11 supports std::string_view, and absl::string_view is meant to be a
 // pybind11 supports std::string_view, and absl::string_view is meant to be a

pybind11_abseil/tests/absl_example.cc

@@ -165,6 +165,29 @@ bool CheckMap(const absl::flat_hash_map<int, int>& map,
   return true;
   return true;
 }
 }
 
 
+absl::node_hash_map<int, int> MakeNodeHashMap(
+    const std::vector<std::pair<int, int>>& keys_and_values) {
+  absl::node_hash_map<int, int> map;
+  for (const auto& kvp : keys_and_values) {
+    map.insert(kvp);
+  }
+  return map;
+}
+
+bool CheckNodeHashMap(const absl::node_hash_map<int, int>& map,
+                      const std::vector<std::pair<int, int>>& keys_and_values) {
+  for (const auto& kvp : keys_and_values) {
+    auto found = map.find(kvp.first);
+    if (found == map.end()) {
+      return false;
+    }
+    if (found->second != kvp.second) {
+      return false;
+    }
+  }
+  return true;
+}
+
 absl::flat_hash_set<int> MakeSet(const std::vector<int>& values) {
 absl::flat_hash_set<int> MakeSet(const std::vector<int>& values) {
   return absl::flat_hash_set<int>(values.begin(), values.end());
   return absl::flat_hash_set<int>(values.begin(), values.end());
 }
 }
@@ -175,6 +198,16 @@ bool CheckSet(const absl::flat_hash_set<int>& set,
   return set == check;
   return set == check;
 }
 }
 
 
+absl::node_hash_set<int> MakeNodeHashSet(const std::vector<int>& values) {
+  return absl::node_hash_set<int>(values.begin(), values.end());
+}
+
+bool CheckNodeHashSet(const absl::node_hash_set<int>& set,
+                      const std::vector<int>& values) {
+  absl::node_hash_set<int> check(values.begin(), values.end());
+  return set == check;
+}
+
 absl::btree_map<int, int> MakeBtreeMap(
 absl::btree_map<int, int> MakeBtreeMap(
     const std::vector<std::pair<int, int>>& keys_and_values) {
     const std::vector<std::pair<int, int>>& keys_and_values) {
   absl::btree_map<int, int> map;
   absl::btree_map<int, int> map;
@@ -362,6 +395,11 @@ PYBIND11_MODULE(absl_example, m) {
   m.def("make_map", &MakeMap, arg("keys_and_values"));
   m.def("make_map", &MakeMap, arg("keys_and_values"));
   m.def("check_map", &CheckMap, arg("map"), arg("keys_and_values"));
   m.def("check_map", &CheckMap, arg("map"), arg("keys_and_values"));
 
 
+  // absl::node_hash_map bindings
+  m.def("make_node_hash_map", &MakeNodeHashMap, arg("keys_and_values"));
+  m.def("check_node_hash_map", &CheckNodeHashMap, arg("map"),
+        arg("keys_and_values"));
+
   // absl::flat_hash_set bindings
   // absl::flat_hash_set bindings
   m.def("make_set", &MakeSet, arg("values"));
   m.def("make_set", &MakeSet, arg("values"));
   m.def("check_set", &CheckSet, arg("set"), arg("values"));
   m.def("check_set", &CheckSet, arg("set"), arg("values"));
@@ -370,6 +408,10 @@ PYBIND11_MODULE(absl_example, m) {
   m.def("make_btree_map", &MakeBtreeMap, arg("keys_and_values"));
   m.def("make_btree_map", &MakeBtreeMap, arg("keys_and_values"));
   m.def("check_btree_map", &CheckBtreeMap, arg("map"), arg("keys_and_values"));
   m.def("check_btree_map", &CheckBtreeMap, arg("map"), arg("keys_and_values"));
 
 
+  // absl::node_hash_set bindings
+  m.def("make_node_hash_set", &MakeNodeHashSet, arg("values"));
+  m.def("check_node_hash_set", &CheckNodeHashSet, arg("set"), arg("values"));
+
   // absl::variant
   // absl::variant
   class_<A>(m, "A").def(init<int>()).def_readonly("a", &A::a);
   class_<A>(m, "A").def(init<int>()).def_readonly("a", &A::a);
   class_<B>(m, "B").def(init<int>()).def_readonly("b", &B::b);
   class_<B>(m, "B").def(init<int>()).def_readonly("b", &B::b);

pybind11_abseil/tests/absl_test.py

@@ -405,6 +405,18 @@ class AbslFlatHashMapTest(absltest.TestCase):
     self.assertTrue(absl_example.check_map(dict(expected), expected))
     self.assertTrue(absl_example.check_map(dict(expected), expected))
 
 
 
 
+class AbslNodeHashMapTest(absltest.TestCase):
+
+  def test_return_map(self):
+    keys_and_values = [(1, 2), (3, 4), (5, 6)]
+    expected = dict(keys_and_values)
+    self.assertEqual(expected, absl_example.make_node_hash_map(keys_and_values))
+
+  def test_pass_map(self):
+    expected = [(10, 20), (30, 40)]
+    self.assertTrue(absl_example.check_node_hash_map(dict(expected), expected))
+
+
 class AbslFlatHashSetTest(absltest.TestCase):
 class AbslFlatHashSetTest(absltest.TestCase):
 
 
   def test_return_set(self):
   def test_return_set(self):
@@ -417,6 +429,18 @@ class AbslFlatHashSetTest(absltest.TestCase):
     self.assertTrue(absl_example.check_set(set(expected), expected))
     self.assertTrue(absl_example.check_set(set(expected), expected))
 
 
 
 
+class AbslNodeHashSetTest(absltest.TestCase):
+
+  def test_return_set(self):
+    values = [1, 3, 7, 5]
+    expected = set(values)
+    self.assertEqual(expected, absl_example.make_node_hash_set(values))
+
+  def test_pass_set(self):
+    expected = [10, 20, 30, 40]
+    self.assertTrue(absl_example.check_node_hash_set(set(expected), expected))
+
+
 class AbslBTreeMapTest(absltest.TestCase):
 class AbslBTreeMapTest(absltest.TestCase):
 
 
   def test_return_map(self):
   def test_return_map(self):