update sources to v12.2.3

[ceph.git] / ceph / src / boost / libs / unordered / test / helpers / equivalent.hpp

diff --git a/ceph/src/boost/libs/unordered/test/helpers/equivalent.hpp b/ceph/src/boost/libs/unordered/test/helpers/equivalent.hpp
index 61b915382a436c3556cfb0bf0bdb878732afe9ee..6d05f20434ade761ffb159201041106c02681683 100644 (file)
--- a/ceph/src/boost/libs/unordered/test/helpers/equivalent.hpp
+++ b/ceph/src/boost/libs/unordered/test/helpers/equivalent.hpp
@@ -6,88 +6,91 @@
 #if !defined(BOOST_UNORDERED_TESTS_EQUIVALENT_HEADER)
 #define BOOST_UNORDERED_TESTS_EQUIVALENT_HEADER
 
-#include <boost/unordered_map.hpp>
-#include <boost/unordered_set.hpp>
-#include <algorithm>
-#include "./metafunctions.hpp"
 #include "./fwd.hpp"
 #include "./list.hpp"
+#include "./metafunctions.hpp"
+#include <algorithm>
+#include <boost/detail/lightweight_test.hpp>
+#include <boost/unordered_map.hpp>
+#include <boost/unordered_set.hpp>
 
-namespace test
-{
-    template <class T1, class T2>
-    bool equivalent_impl(T1 const& x, T2 const& y, base_type) {
-        return x == y;
-    }
+namespace test {
+  template <class T1, class T2>
+  bool equivalent_impl(T1 const& x, T2 const& y, base_type)
+  {
+    return x == y;
+  }
 
-    template <class T>
-    bool equivalent_impl(boost::hash<T> const&, boost::hash<T> const&,
-        derived_type)
-    {
-        return true;
-    }
+  template <class T>
+  bool equivalent_impl(
+    boost::hash<T> const&, boost::hash<T> const&, derived_type)
+  {
+    return true;
+  }
+
+  template <class T>
+  bool equivalent_impl(
+    std::equal_to<T> const&, std::equal_to<T> const&, derived_type)
+  {
+    return true;
+  }
+
+  template <class T1, class T2, class T3, class T4>
+  bool equivalent_impl(
+    std::pair<T1, T2> const& x1, std::pair<T3, T4> const& x2, derived_type)
+  {
+    return equivalent_impl(x1.first, x2.first, derived) &&
+           equivalent_impl(x1.second, x2.second, derived);
+  }
 
-    template <class T>
-    bool equivalent_impl(std::equal_to<T> const&, std::equal_to<T> const&,
-        derived_type)
+  struct equivalent_type
+  {
+    equivalent_type() {}
+
+    template <class T1, class T2>
+    bool operator()(T1 const& x, T2 const& y) const
     {
-        return true;
+      return equivalent_impl(x, y, derived);
     }
+  };
 
-    template <class T1, class T2, class T3, class T4>
-    bool equivalent_impl(std::pair<T1, T2> const& x1,
-            std::pair<T3, T4> const& x2, derived_type) {
-        return equivalent_impl(x1.first, x2.first, derived) &&
-            equivalent_impl(x1.second, x2.second, derived);
-    }
+  const equivalent_type equivalent;
 
-    struct equivalent_type {
-        equivalent_type() {}
+  template <class Container> class unordered_equivalence_tester
+  {
+    BOOST_DEDUCED_TYPENAME Container::size_type size_;
+    BOOST_DEDUCED_TYPENAME Container::hasher hasher_;
+    BOOST_DEDUCED_TYPENAME Container::key_equal key_equal_;
+    float max_load_factor_;
 
-        template <class T1, class T2>
-        bool operator()(T1 const& x, T2 const& y) const {
-            return equivalent_impl(x, y, derived);
-        }
-    };
+    typedef test::list<BOOST_DEDUCED_TYPENAME Container::value_type> value_list;
+    value_list values_;
 
-    const equivalent_type equivalent;
+  public:
+    unordered_equivalence_tester(Container const& x)
+        : size_(x.size()), hasher_(x.hash_function()), key_equal_(x.key_eq()),
+          max_load_factor_(x.max_load_factor()), values_(x.begin(), x.end())
+    {
+      values_.sort();
+    }
 
-    template <class Container>
-    class unordered_equivalence_tester
+    bool operator()(Container const& x) const
     {
-        BOOST_DEDUCED_TYPENAME Container::size_type size_;
-        BOOST_DEDUCED_TYPENAME Container::hasher hasher_;
-        BOOST_DEDUCED_TYPENAME Container::key_equal key_equal_;
-        float max_load_factor_;
-
-        typedef test::list<BOOST_DEDUCED_TYPENAME Container::value_type>
-            value_list;
-        value_list values_;
-    public:
-        unordered_equivalence_tester(Container const &x)
-            : size_(x.size()),
-            hasher_(x.hash_function()), key_equal_(x.key_eq()),
-            max_load_factor_(x.max_load_factor()),
-            values_(x.begin(), x.end())
-        {
-            values_.sort();
-        }
-
-        bool operator()(Container const& x) const
-        {
-            if(!((size_ == x.size()) &&
-                (test::equivalent(hasher_, x.hash_function())) &&
-                (test::equivalent(key_equal_, x.key_eq())) &&
-                (max_load_factor_ == x.max_load_factor()) &&
-                (values_.size() == x.size()))) return false;
-
-            value_list copy(x.begin(), x.end());
-            copy.sort();
-            return values_ == copy;
-        }
-    private:
-        unordered_equivalence_tester();
-    };
+      if (!((size_ == x.size()) &&
+            (test::equivalent(hasher_, x.hash_function())) &&
+            (test::equivalent(key_equal_, x.key_eq())) &&
+            (max_load_factor_ == x.max_load_factor()) &&
+            (values_.size() == x.size())))
+        return false;
+
+      value_list copy(x.begin(), x.end());
+      copy.sort();
+      return values_ == copy;
+    }
+
+  private:
+    unordered_equivalence_tester();
+  };
 }
 
 #endif