Imported Upstream version 1.64.0

[platform/upstream/boost.git] / boost / unordered / unordered_map_fwd.hpp

diff --git a/boost/unordered/unordered_map_fwd.hpp b/boost/unordered/unordered_map_fwd.hpp
index 1eb26ce..12855e9 100644 (file)
--- a/boost/unordered/unordered_map_fwd.hpp
+++ b/boost/unordered/unordered_map_fwd.hpp
@@ -11,55 +11,51 @@
 #pragma once
 #endif
 
-#include <memory>
-#include <functional>
 #include <boost/functional/hash_fwd.hpp>
 #include <boost/unordered/detail/fwd.hpp>
+#include <functional>
+#include <memory>
 
-namespace boost
-{
-    namespace unordered
-    {
-        template <class K,
-            class T,
-            class H = boost::hash<K>,
-            class P = std::equal_to<K>,
-            class A = std::allocator<std::pair<const K, T> > >
-        class unordered_map;
-
-        template <class K, class T, class H, class P, class A>
-        inline bool operator==(unordered_map<K, T, H, P, A> const&,
-            unordered_map<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline bool operator!=(unordered_map<K, T, H, P, A> const&,
-            unordered_map<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline void swap(unordered_map<K, T, H, P, A>&,
-                unordered_map<K, T, H, P, A>&);
-
-        template <class K,
-            class T,
-            class H = boost::hash<K>,
-            class P = std::equal_to<K>,
-            class A = std::allocator<std::pair<const K, T> > >
-        class unordered_multimap;
-
-        template <class K, class T, class H, class P, class A>
-        inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
-            unordered_multimap<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
-            unordered_multimap<K, T, H, P, A> const&);
-        template <class K, class T, class H, class P, class A>
-        inline void swap(unordered_multimap<K, T, H, P, A>&,
-                unordered_multimap<K, T, H, P, A>&);
-    }
+namespace boost {
+namespace unordered {
+template <class K, class T, class H = boost::hash<K>,
+    class P = std::equal_to<K>,
+    class A = std::allocator<std::pair<const K, T> > >
+class unordered_map;
+
+template <class K, class T, class H, class P, class A>
+inline bool operator==(
+    unordered_map<K, T, H, P, A> const&, unordered_map<K, T, H, P, A> const&);
+template <class K, class T, class H, class P, class A>
+inline bool operator!=(
+    unordered_map<K, T, H, P, A> const&, unordered_map<K, T, H, P, A> const&);
+template <class K, class T, class H, class P, class A>
+inline void swap(unordered_map<K, T, H, P, A>&, unordered_map<K, T, H, P, A>&);
+
+template <class K, class T, class H = boost::hash<K>,
+    class P = std::equal_to<K>,
+    class A = std::allocator<std::pair<const K, T> > >
+class unordered_multimap;
+
+template <class K, class T, class H, class P, class A>
+inline bool operator==(unordered_multimap<K, T, H, P, A> const&,
+    unordered_multimap<K, T, H, P, A> const&);
+template <class K, class T, class H, class P, class A>
+inline bool operator!=(unordered_multimap<K, T, H, P, A> const&,
+    unordered_multimap<K, T, H, P, A> const&);
+template <class K, class T, class H, class P, class A>
+inline void swap(
+    unordered_multimap<K, T, H, P, A>&, unordered_multimap<K, T, H, P, A>&);
+
+template <class N, class K, class T, class A> class node_handle_map;
+template <class N, class K, class T, class A> struct insert_return_type_map;
+}
 
-    using boost::unordered::unordered_map;
-    using boost::unordered::unordered_multimap;
-    using boost::unordered::swap;
-    using boost::unordered::operator==;
-    using boost::unordered::operator!=;
+using boost::unordered::unordered_map;
+using boost::unordered::unordered_multimap;
+using boost::unordered::swap;
+using boost::unordered::operator==;
+using boost::unordered::operator!=;
 }
 
 #endif