2 // Copyright (C) 2003-2004 Jeremy B. Maitin-Shepard.
3 // Copyright (C) 2005-2011 Daniel James.
4 // Distributed under the Boost Software License, Version 1.0. (See accompanying
5 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
7 // See http://www.boost.org/libs/unordered for documentation
9 #ifndef BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED
10 #define BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED
12 #include <boost/config.hpp>
13 #if defined(BOOST_HAS_PRAGMA_ONCE)
17 #include <boost/unordered/unordered_map_fwd.hpp>
18 #include <boost/unordered/detail/map.hpp>
19 #include <boost/functional/hash.hpp>
20 #include <boost/move/move.hpp>
22 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
23 #include <initializer_list>
26 #if defined(BOOST_MSVC)
28 #if BOOST_MSVC >= 1400
29 #pragma warning(disable:4396) //the inline specifier cannot be used when a
30 // friend declaration refers to a specialization
31 // of a function template
39 template <class K, class T, class H, class P, class A>
42 #if defined(BOOST_UNORDERED_USE_MOVE)
43 BOOST_COPYABLE_AND_MOVABLE(unordered_map)
49 typedef std::pair<const K, T> value_type;
50 typedef T mapped_type;
53 typedef A allocator_type;
57 typedef boost::unordered::detail::map<A, K, T, H, P> types;
58 typedef typename types::traits allocator_traits;
59 typedef typename types::table table;
63 typedef typename allocator_traits::pointer pointer;
64 typedef typename allocator_traits::const_pointer const_pointer;
66 typedef value_type& reference;
67 typedef value_type const& const_reference;
69 typedef std::size_t size_type;
70 typedef std::ptrdiff_t difference_type;
72 typedef typename table::cl_iterator const_local_iterator;
73 typedef typename table::l_iterator local_iterator;
74 typedef typename table::c_iterator const_iterator;
75 typedef typename table::iterator iterator;
87 explicit unordered_map(
89 const hasher& = hasher(),
90 const key_equal& = key_equal(),
91 const allocator_type& = allocator_type());
93 explicit unordered_map(
95 const allocator_type&);
97 explicit unordered_map(
100 const allocator_type&);
102 explicit unordered_map(allocator_type const&);
104 template <class InputIt>
105 unordered_map(InputIt, InputIt);
107 template <class InputIt>
111 const hasher& = hasher(),
112 const key_equal& = key_equal());
114 template <class InputIt>
120 const allocator_type&);
122 template <class InputIt>
127 const allocator_type&);
129 template <class InputIt>
133 const allocator_type&);
135 // copy/move constructors
137 unordered_map(unordered_map const&);
139 unordered_map(unordered_map const&, allocator_type const&);
140 unordered_map(BOOST_RV_REF(unordered_map), allocator_type const&);
142 #if defined(BOOST_UNORDERED_USE_MOVE)
143 unordered_map(BOOST_RV_REF(unordered_map) other)
144 BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
145 : table_(other.table_, boost::unordered::detail::move_tag())
148 #elif !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
149 unordered_map(unordered_map&& other)
150 BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
151 : table_(other.table_, boost::unordered::detail::move_tag())
156 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
158 std::initializer_list<value_type>,
159 size_type = boost::unordered::detail::default_bucket_count,
160 const hasher& = hasher(),
161 const key_equal&l = key_equal(),
162 const allocator_type& = allocator_type());
164 std::initializer_list<value_type>,
167 const allocator_type&);
169 std::initializer_list<value_type>,
171 const allocator_type&);
176 ~unordered_map() BOOST_NOEXCEPT;
180 #if defined(BOOST_UNORDERED_USE_MOVE)
181 unordered_map& operator=(BOOST_COPY_ASSIGN_REF(unordered_map) x)
183 table_.assign(x.table_);
187 unordered_map& operator=(BOOST_RV_REF(unordered_map) x)
189 table_.move_assign(x.table_);
193 unordered_map& operator=(unordered_map const& x)
195 table_.assign(x.table_);
199 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
200 unordered_map& operator=(unordered_map&& x)
202 table_.move_assign(x.table_);
208 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
209 unordered_map& operator=(std::initializer_list<value_type>);
212 allocator_type get_allocator() const BOOST_NOEXCEPT
214 return table_.node_alloc();
219 bool empty() const BOOST_NOEXCEPT
221 return table_.size_ == 0;
224 size_type size() const BOOST_NOEXCEPT
229 size_type max_size() const BOOST_NOEXCEPT;
233 iterator begin() BOOST_NOEXCEPT
235 return iterator(table_.begin());
238 const_iterator begin() const BOOST_NOEXCEPT
240 return const_iterator(table_.begin());
243 iterator end() BOOST_NOEXCEPT
248 const_iterator end() const BOOST_NOEXCEPT
250 return const_iterator();
253 const_iterator cbegin() const BOOST_NOEXCEPT
255 return const_iterator(table_.begin());
258 const_iterator cend() const BOOST_NOEXCEPT
260 return const_iterator();
265 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
266 template <class... Args>
267 std::pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args)
269 return table_.emplace(boost::forward<Args>(args)...);
272 template <class... Args>
273 iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
275 return table_.emplace_hint(hint, boost::forward<Args>(args)...);
279 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
281 // 0 argument emplace requires special treatment in case
282 // the container is instantiated with a value type that
283 // doesn't have a default constructor.
285 std::pair<iterator, bool> emplace(
286 boost::unordered::detail::empty_emplace
287 = boost::unordered::detail::empty_emplace(),
288 value_type v = value_type())
290 return this->emplace(boost::move(v));
293 iterator emplace_hint(const_iterator hint,
294 boost::unordered::detail::empty_emplace
295 = boost::unordered::detail::empty_emplace(),
296 value_type v = value_type()
299 return this->emplace_hint(hint, boost::move(v));
304 template <typename A0>
305 std::pair<iterator, bool> emplace(BOOST_FWD_REF(A0) a0)
307 return table_.emplace(
308 boost::unordered::detail::create_emplace_args(
309 boost::forward<A0>(a0))
313 template <typename A0>
314 iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
316 return table_.emplace_hint(hint,
317 boost::unordered::detail::create_emplace_args(
318 boost::forward<A0>(a0))
322 template <typename A0, typename A1>
323 std::pair<iterator, bool> emplace(
324 BOOST_FWD_REF(A0) a0,
325 BOOST_FWD_REF(A1) a1)
327 return table_.emplace(
328 boost::unordered::detail::create_emplace_args(
329 boost::forward<A0>(a0),
330 boost::forward<A1>(a1))
334 template <typename A0, typename A1>
335 iterator emplace_hint(const_iterator hint,
336 BOOST_FWD_REF(A0) a0,
337 BOOST_FWD_REF(A1) a1)
339 return table_.emplace_hint(hint,
340 boost::unordered::detail::create_emplace_args(
341 boost::forward<A0>(a0),
342 boost::forward<A1>(a1))
346 template <typename A0, typename A1, typename A2>
347 std::pair<iterator, bool> emplace(
348 BOOST_FWD_REF(A0) a0,
349 BOOST_FWD_REF(A1) a1,
350 BOOST_FWD_REF(A2) a2)
352 return table_.emplace(
353 boost::unordered::detail::create_emplace_args(
354 boost::forward<A0>(a0),
355 boost::forward<A1>(a1),
356 boost::forward<A2>(a2))
360 template <typename A0, typename A1, typename A2>
361 iterator emplace_hint(const_iterator hint,
362 BOOST_FWD_REF(A0) a0,
363 BOOST_FWD_REF(A1) a1,
364 BOOST_FWD_REF(A2) a2)
366 return table_.emplace_hint(hint,
367 boost::unordered::detail::create_emplace_args(
368 boost::forward<A0>(a0),
369 boost::forward<A1>(a1),
370 boost::forward<A2>(a2))
374 #define BOOST_UNORDERED_EMPLACE(z, n, _) \
376 BOOST_PP_ENUM_PARAMS_Z(z, n, typename A) \
378 std::pair<iterator, bool> emplace( \
379 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a) \
382 return table_.emplace( \
383 boost::unordered::detail::create_emplace_args( \
384 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
390 BOOST_PP_ENUM_PARAMS_Z(z, n, typename A) \
392 iterator emplace_hint( \
393 const_iterator hint, \
394 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a) \
397 return table_.emplace_hint(hint, \
398 boost::unordered::detail::create_emplace_args( \
399 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
404 BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
405 BOOST_UNORDERED_EMPLACE, _)
407 #undef BOOST_UNORDERED_EMPLACE
411 std::pair<iterator, bool> insert(value_type const& x)
413 return this->emplace(x);
416 std::pair<iterator, bool> insert(BOOST_RV_REF(value_type) x)
418 return this->emplace(boost::move(x));
421 iterator insert(const_iterator hint, value_type const& x)
423 return this->emplace_hint(hint, x);
426 iterator insert(const_iterator hint, BOOST_RV_REF(value_type) x)
428 return this->emplace_hint(hint, boost::move(x));
431 template <class InputIt> void insert(InputIt, InputIt);
433 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
434 void insert(std::initializer_list<value_type>);
437 iterator erase(const_iterator);
438 size_type erase(const key_type&);
439 iterator erase(const_iterator, const_iterator);
440 void quick_erase(const_iterator it) { erase(it); }
441 void erase_return_void(const_iterator it) { erase(it); }
444 void swap(unordered_map&);
448 hasher hash_function() const;
449 key_equal key_eq() const;
451 mapped_type& operator[](const key_type&);
452 mapped_type& at(const key_type&);
453 mapped_type const& at(const key_type&) const;
457 iterator find(const key_type&);
458 const_iterator find(const key_type&) const;
460 template <class CompatibleKey, class CompatibleHash,
461 class CompatiblePredicate>
463 CompatibleKey const&,
464 CompatibleHash const&,
465 CompatiblePredicate const&);
467 template <class CompatibleKey, class CompatibleHash,
468 class CompatiblePredicate>
470 CompatibleKey const&,
471 CompatibleHash const&,
472 CompatiblePredicate const&) const;
474 size_type count(const key_type&) const;
476 std::pair<iterator, iterator>
477 equal_range(const key_type&);
478 std::pair<const_iterator, const_iterator>
479 equal_range(const key_type&) const;
483 size_type bucket_count() const BOOST_NOEXCEPT
485 return table_.bucket_count_;
488 size_type max_bucket_count() const BOOST_NOEXCEPT
490 return table_.max_bucket_count();
493 size_type bucket_size(size_type) const;
495 size_type bucket(const key_type& k) const
497 return table_.hash_to_bucket(table_.hash(k));
500 local_iterator begin(size_type n)
502 return local_iterator(
503 table_.begin(n), n, table_.bucket_count_);
506 const_local_iterator begin(size_type n) const
508 return const_local_iterator(
509 table_.begin(n), n, table_.bucket_count_);
512 local_iterator end(size_type)
514 return local_iterator();
517 const_local_iterator end(size_type) const
519 return const_local_iterator();
522 const_local_iterator cbegin(size_type n) const
524 return const_local_iterator(
525 table_.begin(n), n, table_.bucket_count_);
528 const_local_iterator cend(size_type) const
530 return const_local_iterator();
535 float max_load_factor() const BOOST_NOEXCEPT
540 float load_factor() const BOOST_NOEXCEPT;
541 void max_load_factor(float) BOOST_NOEXCEPT;
542 void rehash(size_type);
543 void reserve(size_type);
545 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
546 friend bool operator==<K,T,H,P,A>(
547 unordered_map const&, unordered_map const&);
548 friend bool operator!=<K,T,H,P,A>(
549 unordered_map const&, unordered_map const&);
551 }; // class template unordered_map
553 template <class K, class T, class H, class P, class A>
554 class unordered_multimap
556 #if defined(BOOST_UNORDERED_USE_MOVE)
557 BOOST_COPYABLE_AND_MOVABLE(unordered_multimap)
562 typedef std::pair<const K, T> value_type;
563 typedef T mapped_type;
566 typedef A allocator_type;
570 typedef boost::unordered::detail::multimap<A, K, T, H, P> types;
571 typedef typename types::traits allocator_traits;
572 typedef typename types::table table;
576 typedef typename allocator_traits::pointer pointer;
577 typedef typename allocator_traits::const_pointer const_pointer;
579 typedef value_type& reference;
580 typedef value_type const& const_reference;
582 typedef std::size_t size_type;
583 typedef std::ptrdiff_t difference_type;
585 typedef typename table::cl_iterator const_local_iterator;
586 typedef typename table::l_iterator local_iterator;
587 typedef typename table::c_iterator const_iterator;
588 typedef typename table::iterator iterator;
598 unordered_multimap();
600 explicit unordered_multimap(
602 const hasher& = hasher(),
603 const key_equal& = key_equal(),
604 const allocator_type& = allocator_type());
606 explicit unordered_multimap(
608 const allocator_type&);
610 explicit unordered_multimap(
613 const allocator_type&);
615 explicit unordered_multimap(allocator_type const&);
617 template <class InputIt>
618 unordered_multimap(InputIt, InputIt);
620 template <class InputIt>
624 const hasher& = hasher(),
625 const key_equal& = key_equal());
627 template <class InputIt>
633 const allocator_type&);
635 template <class InputIt>
640 const allocator_type&);
642 template <class InputIt>
646 const allocator_type&);
648 // copy/move constructors
650 unordered_multimap(unordered_multimap const&);
652 unordered_multimap(unordered_multimap const&, allocator_type const&);
653 unordered_multimap(BOOST_RV_REF(unordered_multimap), allocator_type const&);
655 #if defined(BOOST_UNORDERED_USE_MOVE)
656 unordered_multimap(BOOST_RV_REF(unordered_multimap) other)
657 BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
658 : table_(other.table_, boost::unordered::detail::move_tag())
661 #elif !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
662 unordered_multimap(unordered_multimap&& other)
663 BOOST_NOEXCEPT_IF(table::nothrow_move_constructible)
664 : table_(other.table_, boost::unordered::detail::move_tag())
669 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
671 std::initializer_list<value_type>,
672 size_type = boost::unordered::detail::default_bucket_count,
673 const hasher& = hasher(),
674 const key_equal&l = key_equal(),
675 const allocator_type& = allocator_type());
677 std::initializer_list<value_type>,
680 const allocator_type&);
682 std::initializer_list<value_type>,
684 const allocator_type&);
689 ~unordered_multimap() BOOST_NOEXCEPT;
693 #if defined(BOOST_UNORDERED_USE_MOVE)
694 unordered_multimap& operator=(
695 BOOST_COPY_ASSIGN_REF(unordered_multimap) x)
697 table_.assign(x.table_);
701 unordered_multimap& operator=(BOOST_RV_REF(unordered_multimap) x)
703 table_.move_assign(x.table_);
707 unordered_multimap& operator=(unordered_multimap const& x)
709 table_.assign(x.table_);
713 #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
714 unordered_multimap& operator=(unordered_multimap&& x)
716 table_.move_assign(x.table_);
722 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
723 unordered_multimap& operator=(std::initializer_list<value_type>);
726 allocator_type get_allocator() const BOOST_NOEXCEPT
728 return table_.node_alloc();
733 bool empty() const BOOST_NOEXCEPT
735 return table_.size_ == 0;
738 size_type size() const BOOST_NOEXCEPT
743 size_type max_size() const BOOST_NOEXCEPT;
747 iterator begin() BOOST_NOEXCEPT
749 return iterator(table_.begin());
752 const_iterator begin() const BOOST_NOEXCEPT
754 return const_iterator(table_.begin());
757 iterator end() BOOST_NOEXCEPT
762 const_iterator end() const BOOST_NOEXCEPT
764 return const_iterator();
767 const_iterator cbegin() const BOOST_NOEXCEPT
769 return const_iterator(table_.begin());
772 const_iterator cend() const BOOST_NOEXCEPT
774 return const_iterator();
779 #if !defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES)
780 template <class... Args>
781 iterator emplace(BOOST_FWD_REF(Args)... args)
783 return table_.emplace(boost::forward<Args>(args)...);
786 template <class... Args>
787 iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(Args)... args)
789 return table_.emplace_hint(hint, boost::forward<Args>(args)...);
793 #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
795 // 0 argument emplace requires special treatment in case
796 // the container is instantiated with a value type that
797 // doesn't have a default constructor.
800 boost::unordered::detail::empty_emplace
801 = boost::unordered::detail::empty_emplace(),
802 value_type v = value_type())
804 return this->emplace(boost::move(v));
807 iterator emplace_hint(const_iterator hint,
808 boost::unordered::detail::empty_emplace
809 = boost::unordered::detail::empty_emplace(),
810 value_type v = value_type()
813 return this->emplace_hint(hint, boost::move(v));
818 template <typename A0>
819 iterator emplace(BOOST_FWD_REF(A0) a0)
821 return table_.emplace(
822 boost::unordered::detail::create_emplace_args(
823 boost::forward<A0>(a0))
827 template <typename A0>
828 iterator emplace_hint(const_iterator hint, BOOST_FWD_REF(A0) a0)
830 return table_.emplace_hint(hint,
831 boost::unordered::detail::create_emplace_args(
832 boost::forward<A0>(a0))
836 template <typename A0, typename A1>
838 BOOST_FWD_REF(A0) a0,
839 BOOST_FWD_REF(A1) a1)
841 return table_.emplace(
842 boost::unordered::detail::create_emplace_args(
843 boost::forward<A0>(a0),
844 boost::forward<A1>(a1))
848 template <typename A0, typename A1>
849 iterator emplace_hint(const_iterator hint,
850 BOOST_FWD_REF(A0) a0,
851 BOOST_FWD_REF(A1) a1)
853 return table_.emplace_hint(hint,
854 boost::unordered::detail::create_emplace_args(
855 boost::forward<A0>(a0),
856 boost::forward<A1>(a1))
860 template <typename A0, typename A1, typename A2>
862 BOOST_FWD_REF(A0) a0,
863 BOOST_FWD_REF(A1) a1,
864 BOOST_FWD_REF(A2) a2)
866 return table_.emplace(
867 boost::unordered::detail::create_emplace_args(
868 boost::forward<A0>(a0),
869 boost::forward<A1>(a1),
870 boost::forward<A2>(a2))
874 template <typename A0, typename A1, typename A2>
875 iterator emplace_hint(const_iterator hint,
876 BOOST_FWD_REF(A0) a0,
877 BOOST_FWD_REF(A1) a1,
878 BOOST_FWD_REF(A2) a2)
880 return table_.emplace_hint(hint,
881 boost::unordered::detail::create_emplace_args(
882 boost::forward<A0>(a0),
883 boost::forward<A1>(a1),
884 boost::forward<A2>(a2))
888 #define BOOST_UNORDERED_EMPLACE(z, n, _) \
890 BOOST_PP_ENUM_PARAMS_Z(z, n, typename A) \
893 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a) \
896 return table_.emplace( \
897 boost::unordered::detail::create_emplace_args( \
898 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
904 BOOST_PP_ENUM_PARAMS_Z(z, n, typename A) \
906 iterator emplace_hint( \
907 const_iterator hint, \
908 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_FWD_PARAM, a) \
911 return table_.emplace_hint(hint, \
912 boost::unordered::detail::create_emplace_args( \
913 BOOST_PP_ENUM_##z(n, BOOST_UNORDERED_CALL_FORWARD, \
918 BOOST_PP_REPEAT_FROM_TO(4, BOOST_UNORDERED_EMPLACE_LIMIT,
919 BOOST_UNORDERED_EMPLACE, _)
921 #undef BOOST_UNORDERED_EMPLACE
925 iterator insert(value_type const& x)
927 return this->emplace(x);
930 iterator insert(BOOST_RV_REF(value_type) x)
932 return this->emplace(boost::move(x));
935 iterator insert(const_iterator hint, value_type const& x)
937 return this->emplace_hint(hint, x);
940 iterator insert(const_iterator hint, BOOST_RV_REF(value_type) x)
942 return this->emplace_hint(hint, boost::move(x));
945 template <class InputIt> void insert(InputIt, InputIt);
947 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
948 void insert(std::initializer_list<value_type>);
951 iterator erase(const_iterator);
952 size_type erase(const key_type&);
953 iterator erase(const_iterator, const_iterator);
954 void quick_erase(const_iterator it) { erase(it); }
955 void erase_return_void(const_iterator it) { erase(it); }
958 void swap(unordered_multimap&);
962 hasher hash_function() const;
963 key_equal key_eq() const;
967 iterator find(const key_type&);
968 const_iterator find(const key_type&) const;
970 template <class CompatibleKey, class CompatibleHash,
971 class CompatiblePredicate>
973 CompatibleKey const&,
974 CompatibleHash const&,
975 CompatiblePredicate const&);
977 template <class CompatibleKey, class CompatibleHash,
978 class CompatiblePredicate>
980 CompatibleKey const&,
981 CompatibleHash const&,
982 CompatiblePredicate const&) const;
984 size_type count(const key_type&) const;
986 std::pair<iterator, iterator>
987 equal_range(const key_type&);
988 std::pair<const_iterator, const_iterator>
989 equal_range(const key_type&) const;
993 size_type bucket_count() const BOOST_NOEXCEPT
995 return table_.bucket_count_;
998 size_type max_bucket_count() const BOOST_NOEXCEPT
1000 return table_.max_bucket_count();
1003 size_type bucket_size(size_type) const;
1005 size_type bucket(const key_type& k) const
1007 return table_.hash_to_bucket(table_.hash(k));
1010 local_iterator begin(size_type n)
1012 return local_iterator(
1013 table_.begin(n), n, table_.bucket_count_);
1016 const_local_iterator begin(size_type n) const
1018 return const_local_iterator(
1019 table_.begin(n), n, table_.bucket_count_);
1022 local_iterator end(size_type)
1024 return local_iterator();
1027 const_local_iterator end(size_type) const
1029 return const_local_iterator();
1032 const_local_iterator cbegin(size_type n) const
1034 return const_local_iterator(
1035 table_.begin(n), n, table_.bucket_count_);
1038 const_local_iterator cend(size_type) const
1040 return const_local_iterator();
1045 float max_load_factor() const BOOST_NOEXCEPT
1050 float load_factor() const BOOST_NOEXCEPT;
1051 void max_load_factor(float) BOOST_NOEXCEPT;
1052 void rehash(size_type);
1053 void reserve(size_type);
1055 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x0582)
1056 friend bool operator==<K,T,H,P,A>(
1057 unordered_multimap const&, unordered_multimap const&);
1058 friend bool operator!=<K,T,H,P,A>(
1059 unordered_multimap const&, unordered_multimap const&);
1061 }; // class template unordered_multimap
1063 ////////////////////////////////////////////////////////////////////////////////
1065 template <class K, class T, class H, class P, class A>
1066 unordered_map<K,T,H,P,A>::unordered_map()
1067 : table_(boost::unordered::detail::default_bucket_count, hasher(),
1068 key_equal(), allocator_type())
1072 template <class K, class T, class H, class P, class A>
1073 unordered_map<K,T,H,P,A>::unordered_map(
1074 size_type n, const hasher &hf, const key_equal &eql,
1075 const allocator_type &a)
1076 : table_(n, hf, eql, a)
1080 template <class K, class T, class H, class P, class A>
1081 unordered_map<K,T,H,P,A>::unordered_map(
1082 size_type n, const allocator_type &a)
1083 : table_(n, hasher(), key_equal(), a)
1087 template <class K, class T, class H, class P, class A>
1088 unordered_map<K,T,H,P,A>::unordered_map(
1089 size_type n, const hasher &hf, const allocator_type &a)
1090 : table_(n, hf, key_equal(), a)
1094 template <class K, class T, class H, class P, class A>
1095 unordered_map<K,T,H,P,A>::unordered_map(allocator_type const& a)
1096 : table_(boost::unordered::detail::default_bucket_count,
1097 hasher(), key_equal(), a)
1101 template <class K, class T, class H, class P, class A>
1102 unordered_map<K,T,H,P,A>::unordered_map(
1103 unordered_map const& other, allocator_type const& a)
1104 : table_(other.table_, a)
1108 template <class K, class T, class H, class P, class A>
1109 template <class InputIt>
1110 unordered_map<K,T,H,P,A>::unordered_map(InputIt f, InputIt l)
1111 : table_(boost::unordered::detail::initial_size(f, l),
1112 hasher(), key_equal(), allocator_type())
1114 table_.insert_range(f, l);
1117 template <class K, class T, class H, class P, class A>
1118 template <class InputIt>
1119 unordered_map<K,T,H,P,A>::unordered_map(
1120 InputIt f, InputIt l,
1123 const key_equal &eql)
1124 : table_(boost::unordered::detail::initial_size(f, l, n),
1125 hf, eql, allocator_type())
1127 table_.insert_range(f, l);
1130 template <class K, class T, class H, class P, class A>
1131 template <class InputIt>
1132 unordered_map<K,T,H,P,A>::unordered_map(
1133 InputIt f, InputIt l,
1136 const key_equal &eql,
1137 const allocator_type &a)
1138 : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
1140 table_.insert_range(f, l);
1143 template <class K, class T, class H, class P, class A>
1144 template <class InputIt>
1145 unordered_map<K,T,H,P,A>::unordered_map(
1146 InputIt f, InputIt l,
1149 const allocator_type &a)
1150 : table_(boost::unordered::detail::initial_size(f, l, n),
1153 table_.insert_range(f, l);
1156 template <class K, class T, class H, class P, class A>
1157 template <class InputIt>
1158 unordered_map<K,T,H,P,A>::unordered_map(
1159 InputIt f, InputIt l,
1161 const allocator_type &a)
1162 : table_(boost::unordered::detail::initial_size(f, l, n),
1163 hasher(), key_equal(), a)
1165 table_.insert_range(f, l);
1168 template <class K, class T, class H, class P, class A>
1169 unordered_map<K,T,H,P,A>::~unordered_map() BOOST_NOEXCEPT {}
1171 template <class K, class T, class H, class P, class A>
1172 unordered_map<K,T,H,P,A>::unordered_map(
1173 unordered_map const& other)
1174 : table_(other.table_)
1178 template <class K, class T, class H, class P, class A>
1179 unordered_map<K,T,H,P,A>::unordered_map(
1180 BOOST_RV_REF(unordered_map) other, allocator_type const& a)
1181 : table_(other.table_, a, boost::unordered::detail::move_tag())
1185 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
1187 template <class K, class T, class H, class P, class A>
1188 unordered_map<K,T,H,P,A>::unordered_map(
1189 std::initializer_list<value_type> list, size_type n,
1190 const hasher &hf, const key_equal &eql, const allocator_type &a)
1192 boost::unordered::detail::initial_size(
1193 list.begin(), list.end(), n),
1196 table_.insert_range(list.begin(), list.end());
1199 template <class K, class T, class H, class P, class A>
1200 unordered_map<K,T,H,P,A>::unordered_map(
1201 std::initializer_list<value_type> list, size_type n,
1202 const hasher &hf, const allocator_type &a)
1204 boost::unordered::detail::initial_size(
1205 list.begin(), list.end(), n),
1208 table_.insert_range(list.begin(), list.end());
1211 template <class K, class T, class H, class P, class A>
1212 unordered_map<K,T,H,P,A>::unordered_map(
1213 std::initializer_list<value_type> list, size_type n,
1214 const allocator_type &a)
1216 boost::unordered::detail::initial_size(
1217 list.begin(), list.end(), n),
1218 hasher(), key_equal(), a)
1220 table_.insert_range(list.begin(), list.end());
1223 template <class K, class T, class H, class P, class A>
1224 unordered_map<K,T,H,P,A>& unordered_map<K,T,H,P,A>::operator=(
1225 std::initializer_list<value_type> list)
1228 table_.insert_range(list.begin(), list.end());
1234 // size and capacity
1236 template <class K, class T, class H, class P, class A>
1237 std::size_t unordered_map<K,T,H,P,A>::max_size() const BOOST_NOEXCEPT
1239 return table_.max_size();
1244 template <class K, class T, class H, class P, class A>
1245 template <class InputIt>
1246 void unordered_map<K,T,H,P,A>::insert(InputIt first, InputIt last)
1248 table_.insert_range(first, last);
1251 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
1252 template <class K, class T, class H, class P, class A>
1253 void unordered_map<K,T,H,P,A>::insert(
1254 std::initializer_list<value_type> list)
1256 table_.insert_range(list.begin(), list.end());
1260 template <class K, class T, class H, class P, class A>
1261 typename unordered_map<K,T,H,P,A>::iterator
1262 unordered_map<K,T,H,P,A>::erase(const_iterator position)
1264 return table_.erase(position);
1267 template <class K, class T, class H, class P, class A>
1268 typename unordered_map<K,T,H,P,A>::size_type
1269 unordered_map<K,T,H,P,A>::erase(const key_type& k)
1271 return table_.erase_key(k);
1274 template <class K, class T, class H, class P, class A>
1275 typename unordered_map<K,T,H,P,A>::iterator
1276 unordered_map<K,T,H,P,A>::erase(
1277 const_iterator first, const_iterator last)
1279 return table_.erase_range(first, last);
1282 template <class K, class T, class H, class P, class A>
1283 void unordered_map<K,T,H,P,A>::clear()
1288 template <class K, class T, class H, class P, class A>
1289 void unordered_map<K,T,H,P,A>::swap(unordered_map& other)
1291 table_.swap(other.table_);
1296 template <class K, class T, class H, class P, class A>
1297 typename unordered_map<K,T,H,P,A>::hasher
1298 unordered_map<K,T,H,P,A>::hash_function() const
1300 return table_.hash_function();
1303 template <class K, class T, class H, class P, class A>
1304 typename unordered_map<K,T,H,P,A>::key_equal
1305 unordered_map<K,T,H,P,A>::key_eq() const
1307 return table_.key_eq();
1310 template <class K, class T, class H, class P, class A>
1311 typename unordered_map<K,T,H,P,A>::mapped_type&
1312 unordered_map<K,T,H,P,A>::operator[](const key_type &k)
1314 return table_[k].second;
1317 template <class K, class T, class H, class P, class A>
1318 typename unordered_map<K,T,H,P,A>::mapped_type&
1319 unordered_map<K,T,H,P,A>::at(const key_type& k)
1321 return table_.at(k).second;
1324 template <class K, class T, class H, class P, class A>
1325 typename unordered_map<K,T,H,P,A>::mapped_type const&
1326 unordered_map<K,T,H,P,A>::at(const key_type& k) const
1328 return table_.at(k).second;
1333 template <class K, class T, class H, class P, class A>
1334 typename unordered_map<K,T,H,P,A>::iterator
1335 unordered_map<K,T,H,P,A>::find(const key_type& k)
1337 return iterator(table_.find_node(k));
1340 template <class K, class T, class H, class P, class A>
1341 typename unordered_map<K,T,H,P,A>::const_iterator
1342 unordered_map<K,T,H,P,A>::find(const key_type& k) const
1344 return const_iterator(table_.find_node(k));
1347 template <class K, class T, class H, class P, class A>
1348 template <class CompatibleKey, class CompatibleHash,
1349 class CompatiblePredicate>
1350 typename unordered_map<K,T,H,P,A>::iterator
1351 unordered_map<K,T,H,P,A>::find(
1352 CompatibleKey const& k,
1353 CompatibleHash const& hash,
1354 CompatiblePredicate const& eq)
1356 return iterator(table_.generic_find_node(k, hash, eq));
1359 template <class K, class T, class H, class P, class A>
1360 template <class CompatibleKey, class CompatibleHash,
1361 class CompatiblePredicate>
1362 typename unordered_map<K,T,H,P,A>::const_iterator
1363 unordered_map<K,T,H,P,A>::find(
1364 CompatibleKey const& k,
1365 CompatibleHash const& hash,
1366 CompatiblePredicate const& eq) const
1368 return const_iterator(table_.generic_find_node(k, hash, eq));
1371 template <class K, class T, class H, class P, class A>
1372 typename unordered_map<K,T,H,P,A>::size_type
1373 unordered_map<K,T,H,P,A>::count(const key_type& k) const
1375 return table_.count(k);
1378 template <class K, class T, class H, class P, class A>
1380 typename unordered_map<K,T,H,P,A>::iterator,
1381 typename unordered_map<K,T,H,P,A>::iterator>
1382 unordered_map<K,T,H,P,A>::equal_range(const key_type& k)
1384 return table_.equal_range(k);
1387 template <class K, class T, class H, class P, class A>
1389 typename unordered_map<K,T,H,P,A>::const_iterator,
1390 typename unordered_map<K,T,H,P,A>::const_iterator>
1391 unordered_map<K,T,H,P,A>::equal_range(const key_type& k) const
1393 return table_.equal_range(k);
1396 template <class K, class T, class H, class P, class A>
1397 typename unordered_map<K,T,H,P,A>::size_type
1398 unordered_map<K,T,H,P,A>::bucket_size(size_type n) const
1400 return table_.bucket_size(n);
1405 template <class K, class T, class H, class P, class A>
1406 float unordered_map<K,T,H,P,A>::load_factor() const BOOST_NOEXCEPT
1408 return table_.load_factor();
1411 template <class K, class T, class H, class P, class A>
1412 void unordered_map<K,T,H,P,A>::max_load_factor(float m) BOOST_NOEXCEPT
1414 table_.max_load_factor(m);
1417 template <class K, class T, class H, class P, class A>
1418 void unordered_map<K,T,H,P,A>::rehash(size_type n)
1423 template <class K, class T, class H, class P, class A>
1424 void unordered_map<K,T,H,P,A>::reserve(size_type n)
1429 template <class K, class T, class H, class P, class A>
1430 inline bool operator==(
1431 unordered_map<K,T,H,P,A> const& m1,
1432 unordered_map<K,T,H,P,A> const& m2)
1434 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
1435 struct dummy { unordered_map<K,T,H,P,A> x; };
1437 return m1.table_.equals(m2.table_);
1440 template <class K, class T, class H, class P, class A>
1441 inline bool operator!=(
1442 unordered_map<K,T,H,P,A> const& m1,
1443 unordered_map<K,T,H,P,A> const& m2)
1445 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
1446 struct dummy { unordered_map<K,T,H,P,A> x; };
1448 return !m1.table_.equals(m2.table_);
1451 template <class K, class T, class H, class P, class A>
1453 unordered_map<K,T,H,P,A> &m1,
1454 unordered_map<K,T,H,P,A> &m2)
1456 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
1457 struct dummy { unordered_map<K,T,H,P,A> x; };
1462 ////////////////////////////////////////////////////////////////////////////////
1464 template <class K, class T, class H, class P, class A>
1465 unordered_multimap<K,T,H,P,A>::unordered_multimap()
1466 : table_(boost::unordered::detail::default_bucket_count, hasher(),
1467 key_equal(), allocator_type())
1471 template <class K, class T, class H, class P, class A>
1472 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1473 size_type n, const hasher &hf, const key_equal &eql,
1474 const allocator_type &a)
1475 : table_(n, hf, eql, a)
1479 template <class K, class T, class H, class P, class A>
1480 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1481 size_type n, const allocator_type &a)
1482 : table_(n, hasher(), key_equal(), a)
1486 template <class K, class T, class H, class P, class A>
1487 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1488 size_type n, const hasher &hf, const allocator_type &a)
1489 : table_(n, hf, key_equal(), a)
1493 template <class K, class T, class H, class P, class A>
1494 unordered_multimap<K,T,H,P,A>::unordered_multimap(allocator_type const& a)
1495 : table_(boost::unordered::detail::default_bucket_count,
1496 hasher(), key_equal(), a)
1500 template <class K, class T, class H, class P, class A>
1501 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1502 unordered_multimap const& other, allocator_type const& a)
1503 : table_(other.table_, a)
1507 template <class K, class T, class H, class P, class A>
1508 template <class InputIt>
1509 unordered_multimap<K,T,H,P,A>::unordered_multimap(InputIt f, InputIt l)
1510 : table_(boost::unordered::detail::initial_size(f, l),
1511 hasher(), key_equal(), allocator_type())
1513 table_.insert_range(f, l);
1516 template <class K, class T, class H, class P, class A>
1517 template <class InputIt>
1518 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1519 InputIt f, InputIt l,
1522 const key_equal &eql)
1523 : table_(boost::unordered::detail::initial_size(f, l, n),
1524 hf, eql, allocator_type())
1526 table_.insert_range(f, l);
1529 template <class K, class T, class H, class P, class A>
1530 template <class InputIt>
1531 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1532 InputIt f, InputIt l,
1535 const key_equal &eql,
1536 const allocator_type &a)
1537 : table_(boost::unordered::detail::initial_size(f, l, n), hf, eql, a)
1539 table_.insert_range(f, l);
1542 template <class K, class T, class H, class P, class A>
1543 template <class InputIt>
1544 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1545 InputIt f, InputIt l,
1548 const allocator_type &a)
1549 : table_(boost::unordered::detail::initial_size(f, l, n),
1552 table_.insert_range(f, l);
1555 template <class K, class T, class H, class P, class A>
1556 template <class InputIt>
1557 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1558 InputIt f, InputIt l,
1560 const allocator_type &a)
1561 : table_(boost::unordered::detail::initial_size(f, l, n),
1562 hasher(), key_equal(), a)
1564 table_.insert_range(f, l);
1567 template <class K, class T, class H, class P, class A>
1568 unordered_multimap<K,T,H,P,A>::~unordered_multimap() BOOST_NOEXCEPT {}
1570 template <class K, class T, class H, class P, class A>
1571 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1572 unordered_multimap const& other)
1573 : table_(other.table_)
1577 template <class K, class T, class H, class P, class A>
1578 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1579 BOOST_RV_REF(unordered_multimap) other, allocator_type const& a)
1580 : table_(other.table_, a, boost::unordered::detail::move_tag())
1584 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
1586 template <class K, class T, class H, class P, class A>
1587 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1588 std::initializer_list<value_type> list, size_type n,
1589 const hasher &hf, const key_equal &eql, const allocator_type &a)
1591 boost::unordered::detail::initial_size(
1592 list.begin(), list.end(), n),
1595 table_.insert_range(list.begin(), list.end());
1598 template <class K, class T, class H, class P, class A>
1599 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1600 std::initializer_list<value_type> list, size_type n,
1601 const hasher &hf, const allocator_type &a)
1603 boost::unordered::detail::initial_size(
1604 list.begin(), list.end(), n),
1607 table_.insert_range(list.begin(), list.end());
1610 template <class K, class T, class H, class P, class A>
1611 unordered_multimap<K,T,H,P,A>::unordered_multimap(
1612 std::initializer_list<value_type> list, size_type n,
1613 const allocator_type &a)
1615 boost::unordered::detail::initial_size(
1616 list.begin(), list.end(), n),
1617 hasher(), key_equal(), a)
1619 table_.insert_range(list.begin(), list.end());
1622 template <class K, class T, class H, class P, class A>
1623 unordered_multimap<K,T,H,P,A>& unordered_multimap<K,T,H,P,A>::operator=(
1624 std::initializer_list<value_type> list)
1627 table_.insert_range(list.begin(), list.end());
1633 // size and capacity
1635 template <class K, class T, class H, class P, class A>
1636 std::size_t unordered_multimap<K,T,H,P,A>::max_size() const BOOST_NOEXCEPT
1638 return table_.max_size();
1643 template <class K, class T, class H, class P, class A>
1644 template <class InputIt>
1645 void unordered_multimap<K,T,H,P,A>::insert(InputIt first, InputIt last)
1647 table_.insert_range(first, last);
1650 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
1651 template <class K, class T, class H, class P, class A>
1652 void unordered_multimap<K,T,H,P,A>::insert(
1653 std::initializer_list<value_type> list)
1655 table_.insert_range(list.begin(), list.end());
1659 template <class K, class T, class H, class P, class A>
1660 typename unordered_multimap<K,T,H,P,A>::iterator
1661 unordered_multimap<K,T,H,P,A>::erase(const_iterator position)
1663 return table_.erase(position);
1666 template <class K, class T, class H, class P, class A>
1667 typename unordered_multimap<K,T,H,P,A>::size_type
1668 unordered_multimap<K,T,H,P,A>::erase(const key_type& k)
1670 return table_.erase_key(k);
1673 template <class K, class T, class H, class P, class A>
1674 typename unordered_multimap<K,T,H,P,A>::iterator
1675 unordered_multimap<K,T,H,P,A>::erase(
1676 const_iterator first, const_iterator last)
1678 return table_.erase_range(first, last);
1681 template <class K, class T, class H, class P, class A>
1682 void unordered_multimap<K,T,H,P,A>::clear()
1687 template <class K, class T, class H, class P, class A>
1688 void unordered_multimap<K,T,H,P,A>::swap(unordered_multimap& other)
1690 table_.swap(other.table_);
1695 template <class K, class T, class H, class P, class A>
1696 typename unordered_multimap<K,T,H,P,A>::hasher
1697 unordered_multimap<K,T,H,P,A>::hash_function() const
1699 return table_.hash_function();
1702 template <class K, class T, class H, class P, class A>
1703 typename unordered_multimap<K,T,H,P,A>::key_equal
1704 unordered_multimap<K,T,H,P,A>::key_eq() const
1706 return table_.key_eq();
1711 template <class K, class T, class H, class P, class A>
1712 typename unordered_multimap<K,T,H,P,A>::iterator
1713 unordered_multimap<K,T,H,P,A>::find(const key_type& k)
1715 return iterator(table_.find_node(k));
1718 template <class K, class T, class H, class P, class A>
1719 typename unordered_multimap<K,T,H,P,A>::const_iterator
1720 unordered_multimap<K,T,H,P,A>::find(const key_type& k) const
1722 return const_iterator(table_.find_node(k));
1725 template <class K, class T, class H, class P, class A>
1726 template <class CompatibleKey, class CompatibleHash,
1727 class CompatiblePredicate>
1728 typename unordered_multimap<K,T,H,P,A>::iterator
1729 unordered_multimap<K,T,H,P,A>::find(
1730 CompatibleKey const& k,
1731 CompatibleHash const& hash,
1732 CompatiblePredicate const& eq)
1734 return iterator(table_.generic_find_node(k, hash, eq));
1737 template <class K, class T, class H, class P, class A>
1738 template <class CompatibleKey, class CompatibleHash,
1739 class CompatiblePredicate>
1740 typename unordered_multimap<K,T,H,P,A>::const_iterator
1741 unordered_multimap<K,T,H,P,A>::find(
1742 CompatibleKey const& k,
1743 CompatibleHash const& hash,
1744 CompatiblePredicate const& eq) const
1746 return const_iterator(table_.generic_find_node(k, hash, eq));
1749 template <class K, class T, class H, class P, class A>
1750 typename unordered_multimap<K,T,H,P,A>::size_type
1751 unordered_multimap<K,T,H,P,A>::count(const key_type& k) const
1753 return table_.count(k);
1756 template <class K, class T, class H, class P, class A>
1758 typename unordered_multimap<K,T,H,P,A>::iterator,
1759 typename unordered_multimap<K,T,H,P,A>::iterator>
1760 unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k)
1762 return table_.equal_range(k);
1765 template <class K, class T, class H, class P, class A>
1767 typename unordered_multimap<K,T,H,P,A>::const_iterator,
1768 typename unordered_multimap<K,T,H,P,A>::const_iterator>
1769 unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k) const
1771 return table_.equal_range(k);
1774 template <class K, class T, class H, class P, class A>
1775 typename unordered_multimap<K,T,H,P,A>::size_type
1776 unordered_multimap<K,T,H,P,A>::bucket_size(size_type n) const
1778 return table_.bucket_size(n);
1783 template <class K, class T, class H, class P, class A>
1784 float unordered_multimap<K,T,H,P,A>::load_factor() const BOOST_NOEXCEPT
1786 return table_.load_factor();
1789 template <class K, class T, class H, class P, class A>
1790 void unordered_multimap<K,T,H,P,A>::max_load_factor(float m) BOOST_NOEXCEPT
1792 table_.max_load_factor(m);
1795 template <class K, class T, class H, class P, class A>
1796 void unordered_multimap<K,T,H,P,A>::rehash(size_type n)
1801 template <class K, class T, class H, class P, class A>
1802 void unordered_multimap<K,T,H,P,A>::reserve(size_type n)
1807 template <class K, class T, class H, class P, class A>
1808 inline bool operator==(
1809 unordered_multimap<K,T,H,P,A> const& m1,
1810 unordered_multimap<K,T,H,P,A> const& m2)
1812 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
1813 struct dummy { unordered_multimap<K,T,H,P,A> x; };
1815 return m1.table_.equals(m2.table_);
1818 template <class K, class T, class H, class P, class A>
1819 inline bool operator!=(
1820 unordered_multimap<K,T,H,P,A> const& m1,
1821 unordered_multimap<K,T,H,P,A> const& m2)
1823 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
1824 struct dummy { unordered_multimap<K,T,H,P,A> x; };
1826 return !m1.table_.equals(m2.table_);
1829 template <class K, class T, class H, class P, class A>
1831 unordered_multimap<K,T,H,P,A> &m1,
1832 unordered_multimap<K,T,H,P,A> &m2)
1834 #if BOOST_WORKAROUND(__CODEGEARC__, BOOST_TESTED_AT(0x0613))
1835 struct dummy { unordered_multimap<K,T,H,P,A> x; };
1840 } // namespace unordered
1841 } // namespace boost
1843 #if defined(BOOST_MSVC)
1844 #pragma warning(pop)
1847 #endif // BOOST_UNORDERED_UNORDERED_MAP_HPP_INCLUDED