Add fwd header

include/boost/unordered/concurrent_flat_map.hpp

@@ -15,6 +15,7 @@
 #ifndef BOOST_UNORDERED_CONCURRENT_FLAT_MAP_HPP
 #define BOOST_UNORDERED_CONCURRENT_FLAT_MAP_HPP
 
+#include <boost/unordered/concurrent_flat_map_fwd.hpp>
 #include <boost/unordered/detail/foa/concurrent_table.hpp>
 #include <boost/unordered/detail/type_traits.hpp>
 
@@ -134,9 +135,7 @@ namespace boost {
       };
     } // namespace detail
 
-    template <class Key, class T, class Hash = boost::hash<Key>,
-      class Pred = std::equal_to<Key>,
-      class Allocator = std::allocator<std::pair<Key const, T> > >
+    template <class Key, class T, class Hash, class Pred, class Allocator>
     class concurrent_flat_map
     {
     private:
@@ -803,6 +802,7 @@ namespace boost {
 
   } // namespace unordered
 
+  using unordered::concurrent_flat_map;
 } // namespace boost
 
 #undef BOOST_UNORDERED_STATIC_ASSERT_INVOCABLE

include/boost/unordered/concurrent_flat_map_fwd.hpp

@@ -0,0 +1,58 @@
+/* Fast open-addressing concurrent hash table.
+ *
+ * Copyright 2023 Christian Mazakas.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt)
+ *
+ * See https://www.boost.org/libs/unordered for library home page.
+ */
+
+/* Reference:
+ * https://github.com/joaquintides/concurrent_hashmap_api#proposed-synopsis
+ */
+
+#ifndef BOOST_UNORDERED_CONCURRENT_FLAT_MAP_FWD_HPP
+#define BOOST_UNORDERED_CONCURRENT_FLAT_MAP_FWD_HPP
+
+#include <boost/container_hash/hash_fwd.hpp>
+
+#include <functional>
+#include <memory>
+
+namespace boost {
+  namespace unordered {
+
+    template <class Key, class T, class Hash = boost::hash<Key>,
+      class Pred = std::equal_to<Key>,
+      class Allocator = std::allocator<std::pair<Key const, T> > >
+    class concurrent_flat_map;
+
+    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);
+
+    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);
+
+    template <class Key, class T, class Hash, class Pred, class Alloc>
+    void swap(concurrent_flat_map<Key, T, Hash, Pred, Alloc>& x,
+      concurrent_flat_map<Key, T, Hash, Pred, Alloc>& y)
+      noexcept(noexcept(x.swap(y)));
+
+    template <class K, class T, class H, class P, class A, class Predicate>
+    typename concurrent_flat_map<K, T, H, P, A>::size_type erase_if(
+      concurrent_flat_map<K, T, H, P, A>& c, Predicate pred);
+
+  } // namespace unordered
+
+  using unordered::concurrent_flat_map;
+  using unordered::swap;
+  using unordered::operator==;
+  using unordered::operator!=;
+} // namespace boost
+
+#endif // BOOST_UNORDERED_CONCURRENT_FLAT_MAP_HPP

test/Jamfile.v2

@@ -189,6 +189,7 @@ local CFOA_TESTS =
   merge_tests
   rehash_tests
   equality_tests
+  fwd_tests
 ;
 
 for local test in $(CFOA_TESTS)

test/cfoa/fwd_tests.cpp

@@ -0,0 +1,55 @@
+// Copyright (C) 2023 Christian Mazakas
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include "helpers.hpp"
+
+#include <boost/unordered/concurrent_flat_map_fwd.hpp>
+
+test::seed_t initialize_seed{32304628};
+
+using test::default_generator;
+using test::limited_range;
+using test::sequential;
+
+template <class T>
+void swap_call(boost::unordered::concurrent_flat_map<T, T>& x1,
+  boost::unordered::concurrent_flat_map<T, T>& x2)
+{
+  swap(x1, x2);
+}
+
+template <class T>
+bool equal_call(boost::unordered::concurrent_flat_map<T, T>& x1,
+  boost::unordered::concurrent_flat_map<T, T>& x2)
+{
+  return x1 == x2;
+}
+
+template <class T>
+bool unequal_call(boost::unordered::concurrent_flat_map<T, T>& x1,
+  boost::unordered::concurrent_flat_map<T, T>& x2)
+{
+  return x1 != x2;
+}
+
+#include <boost/unordered/concurrent_flat_map.hpp>
+
+using map_type = boost::unordered::concurrent_flat_map<int, int>;
+
+UNORDERED_AUTO_TEST (fwd_swap_call) {
+  map_type x1, x2;
+  swap_call(x1, x2);
+}
+
+UNORDERED_AUTO_TEST (fwd_equal_call) {
+  map_type x1, x2;
+  BOOST_TEST(equal_call(x1, x2));
+}
+
+UNORDERED_AUTO_TEST (fwd_unequal_call) {
+  map_type x1, x2;
+  BOOST_TEST_NOT(unequal_call(x1, x2));
+}
+
+RUN_TESTS()