From d615a08f76fae442984009d45389e959065829b9 Mon Sep 17 00:00:00 2001
From: joaquintides <joaquin@tid.es>
Date: Fri, 12 May 2023 12:33:27 +0200
Subject: [PATCH] made operator [==|!=] templated again to accommodate fwd
 declarations

---
 .../boost/unordered/concurrent_flat_map.hpp   | 36 +++++++++++--------
 .../boost/unordered/unordered_flat_map.hpp    | 36 +++++++++++--------
 .../boost/unordered/unordered_flat_set.hpp    | 36 +++++++++++--------
 .../boost/unordered/unordered_node_map.hpp    | 36 +++++++++++--------
 .../boost/unordered/unordered_node_set.hpp    | 36 +++++++++++--------
 5 files changed, 105 insertions(+), 75 deletions(-)

diff --git a/include/boost/unordered/concurrent_flat_map.hpp b/include/boost/unordered/concurrent_flat_map.hpp
index d17942cf..4d5d6d64 100644
--- a/include/boost/unordered/concurrent_flat_map.hpp
+++ b/include/boost/unordered/concurrent_flat_map.hpp
@@ -148,6 +148,11 @@ namespace boost {
 
       detail::foa::concurrent_table<type_policy, Hash, Pred, Allocator> table_;
 
+      template <class K, class V, class H, class KE, class A>
+      bool friend operator==(
+        concurrent_flat_map<K, V, H, KE, A> const& lhs,
+        concurrent_flat_map<K, V, H, KE, A> const& rhs);
+
     public:
       using key_type = Key;
       using mapped_type = T;
@@ -766,22 +771,23 @@ namespace boost {
 
       hasher hash_function() const { return table_.hash_function(); }
       key_equal key_eq() const { return table_.key_eq(); }
-
-      /// Equality
-      ///
-      
-      friend bool operator==(
-        concurrent_flat_map const& lhs, concurrent_flat_map const& rhs)
-      {
-        return lhs.table_ == rhs.table_;
-      }
-
-      friend bool operator!=(
-        concurrent_flat_map const& lhs, concurrent_flat_map const& rhs)
-      {
-        return !(lhs == rhs);
-      }
     };
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    bool operator==(
+      concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return lhs.table_ == rhs.table_;
+    }
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    bool operator!=(
+      concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return !(lhs == rhs);
+    }
   } // namespace unordered
 } // namespace boost
 
diff --git a/include/boost/unordered/unordered_flat_map.hpp b/include/boost/unordered/unordered_flat_map.hpp
index 633f466b..23a13438 100644
--- a/include/boost/unordered/unordered_flat_map.hpp
+++ b/include/boost/unordered/unordered_flat_map.hpp
@@ -100,6 +100,11 @@ namespace boost {
 
       table_type table_;
 
+      template <class K, class V, class H, class KE, class A>
+      bool friend operator==(
+        unordered_flat_map<K, V, H, KE, A> const& lhs,
+        unordered_flat_map<K, V, H, KE, A> const& rhs);
+
       template <class K, class V, class H, class KE, class A, class Pred>
       typename unordered_flat_map<K, V, H, KE, A>::size_type friend erase_if(
         unordered_flat_map<K, V, H, KE, A>& set, Pred pred);
@@ -695,23 +700,24 @@ namespace boost {
       hasher hash_function() const { return table_.hash_function(); }
 
       key_equal key_eq() const { return table_.key_eq(); }
-
-      /// Equality
-      ///
-      
-      friend bool operator==(
-        unordered_flat_map const& lhs, unordered_flat_map const& rhs)
-      {
-        return lhs.table_ == rhs.table_;
-      }
-
-      friend bool operator!=(
-        unordered_flat_map const& lhs, unordered_flat_map const& rhs)
-      {
-        return !(lhs == rhs);
-      }
     };
 
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    bool operator==(
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return lhs.table_ == rhs.table_;
+    }
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    bool operator!=(
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return !(lhs == rhs);
+    }
+
     template <class Key, class T, class Hash, class KeyEqual, class Allocator>
     void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& lhs,
       unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& rhs)
diff --git a/include/boost/unordered/unordered_flat_set.hpp b/include/boost/unordered/unordered_flat_set.hpp
index eb0aa728..d81e1082 100644
--- a/include/boost/unordered/unordered_flat_set.hpp
+++ b/include/boost/unordered/unordered_flat_set.hpp
@@ -69,6 +69,11 @@ namespace boost {
 
       table_type table_;
 
+      template <class K, class H, class KE, class A>
+      bool friend operator==(
+        unordered_flat_set<K, H, KE, A> const& lhs,
+        unordered_flat_set<K, H, KE, A> const& rhs);
+
       template <class K, class H, class KE, class A, class Pred>
       typename unordered_flat_set<K, H, KE, A>::size_type friend erase_if(
         unordered_flat_set<K, H, KE, A>& set, Pred pred);
@@ -492,23 +497,24 @@ namespace boost {
       hasher hash_function() const { return table_.hash_function(); }
 
       key_equal key_eq() const { return table_.key_eq(); }
-
-      /// Equality
-      ///
-      
-      friend bool operator==(
-        unordered_flat_set const& lhs, unordered_flat_set const& rhs)
-      {
-        return lhs.table_ == rhs.table_;
-      }
-
-      friend bool operator!=(
-        unordered_flat_set const& lhs, unordered_flat_set const& rhs)
-      {
-        return !(lhs == rhs);
-      }
     };
 
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator==(
+      unordered_flat_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_set<Key, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return lhs.table_ == rhs.table_;
+    }
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator!=(
+      unordered_flat_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_flat_set<Key, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return !(lhs == rhs);
+    }
+
     template <class Key, class Hash, class KeyEqual, class Allocator>
     void swap(unordered_flat_set<Key, Hash, KeyEqual, Allocator>& lhs,
       unordered_flat_set<Key, Hash, KeyEqual, Allocator>& rhs)
diff --git a/include/boost/unordered/unordered_node_map.hpp b/include/boost/unordered/unordered_node_map.hpp
index 910996c5..8d32ba0a 100644
--- a/include/boost/unordered/unordered_node_map.hpp
+++ b/include/boost/unordered/unordered_node_map.hpp
@@ -187,6 +187,11 @@ namespace boost {
 
       table_type table_;
 
+      template <class K, class V, class H, class KE, class A>
+      bool friend operator==(
+        unordered_node_map<K, V, H, KE, A> const& lhs,
+        unordered_node_map<K, V, H, KE, A> const& rhs);
+
       template <class K, class V, class H, class KE, class A, class Pred>
       typename unordered_node_map<K, V, H, KE, A>::size_type friend erase_if(
         unordered_node_map<K, V, H, KE, A>& set, Pred pred);
@@ -847,23 +852,24 @@ namespace boost {
       hasher hash_function() const { return table_.hash_function(); }
 
       key_equal key_eq() const { return table_.key_eq(); }
-
-      /// Equality
-      ///
-      
-      friend bool operator==(
-        unordered_node_map const& lhs, unordered_node_map const& rhs)
-      {
-        return lhs.table_ == rhs.table_;
-      }
-
-      friend bool operator!=(
-        unordered_node_map const& lhs, unordered_node_map const& rhs)
-      {
-        return !(lhs == rhs);
-      }
     };
 
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    bool operator==(
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return lhs.table_ == rhs.table_;
+    }
+
+    template <class Key, class T, class Hash, class KeyEqual, class Allocator>
+    bool operator!=(
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return !(lhs == rhs);
+    }
+
     template <class Key, class T, class Hash, class KeyEqual, class Allocator>
     void swap(unordered_node_map<Key, T, Hash, KeyEqual, Allocator>& lhs,
       unordered_node_map<Key, T, Hash, KeyEqual, Allocator>& rhs)
diff --git a/include/boost/unordered/unordered_node_set.hpp b/include/boost/unordered/unordered_node_set.hpp
index f9f3762d..87d8677f 100644
--- a/include/boost/unordered/unordered_node_set.hpp
+++ b/include/boost/unordered/unordered_node_set.hpp
@@ -143,6 +143,11 @@ namespace boost {
 
       table_type table_;
 
+      template <class K, class H, class KE, class A>
+      bool friend operator==(
+        unordered_node_set<K, H, KE, A> const& lhs,
+        unordered_node_set<K, H, KE, A> const& rhs);
+
       template <class K, class H, class KE, class A, class Pred>
       typename unordered_node_set<K, H, KE, A>::size_type friend erase_if(
         unordered_node_set<K, H, KE, A>& set, Pred pred);
@@ -631,23 +636,24 @@ namespace boost {
       hasher hash_function() const { return table_.hash_function(); }
 
       key_equal key_eq() const { return table_.key_eq(); }
-
-      /// Equality
-      ///
-
-      friend bool operator==(
-        unordered_node_set const& lhs, unordered_node_set const& rhs)
-      {
-        return lhs.table_ == rhs.table_;
-      }
-
-      friend bool operator!=(
-        unordered_node_set const& lhs, unordered_node_set const& rhs)
-      {
-        return !(lhs == rhs);
-      }
     };
 
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator==(
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return lhs.table_ == rhs.table_;
+    }
+
+    template <class Key, class Hash, class KeyEqual, class Allocator>
+    bool operator!=(
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
+      unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs)
+    {
+      return !(lhs == rhs);
+    }
+
     template <class Key, class Hash, class KeyEqual, class Allocator>
     void swap(unordered_node_set<Key, Hash, KeyEqual, Allocator>& lhs,
       unordered_node_set<Key, Hash, KeyEqual, Allocator>& rhs)