feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests Activity

Unordered: Remove BOOST_DEDUCED_TYPENAME

Browse Source 
[SVN r74192]
This commit is contained in:
Daniel James
2011-09-02 08:28:19 +00:00
parent 41b9b8d841
commit a3ffd4a7c9
10 changed files with 263 additions and 290 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
include/boost/unordered/detail/allocator_helpers.hpp
View File

@ -78,14 +78,12 @@ namespace boost { namespace unordered { namespace detail {
template <typename Alloc, typename T> template <typename Alloc, typename T>
struct rebind_wrap struct rebind_wrap
{ {
typedef BOOST_DEDUCED_TYPENAME typedef typename Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
Alloc::BOOST_NESTED_TEMPLATE rebind<T>::other
type; type;
}; };
# endif # endif
template <typename T> BOOST_DEDUCED_TYPENAME template <typename T> typename boost::add_lvalue_reference<T>::type make();
boost::add_lvalue_reference<T>::type make();
struct choice9 { typedef char (&type)[9]; }; struct choice9 { typedef char (&type)[9]; };
struct choice8 : choice9 { typedef char (&type)[8]; }; struct choice8 : choice9 { typedef char (&type)[8]; };
struct choice7 : choice8 { typedef char (&type)[7]; }; struct choice7 : choice8 { typedef char (&type)[7]; };
@ -104,8 +102,7 @@ namespace boost { namespace unordered { namespace detail {
struct default_type_ ## tname { \ struct default_type_ ## tname { \
\ \
template <typename X> \ template <typename X> \
static choice1::type test(choice1, \ static choice1::type test(choice1, typename X::tname* = 0); \
BOOST_DEDUCED_TYPENAME X::tname* = 0); \
\ \
template <typename X> \ template <typename X> \
static choice2::type test(choice2, void* = 0); \ static choice2::type test(choice2, void* = 0); \
@ -114,8 +111,7 @@ namespace boost { namespace unordered { namespace detail {
\ \
enum { value = (1 == sizeof(test<Tp>(choose()))) }; \ enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
\ \
typedef BOOST_DEDUCED_TYPENAME \ typedef typename boost::detail::if_true<value>:: \
boost::detail::if_true<value>:: \
BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \ BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
::type::tname type; \ ::type::tname type; \
} }
@ -130,8 +126,7 @@ namespace boost { namespace unordered { namespace detail {
struct default_type_ ## tname { \ struct default_type_ ## tname { \
\ \
template <typename X> \ template <typename X> \
static BOOST_DEDUCED_TYPENAME sfinae< \ static typename sfinae<typename X::tname, choice1>::type \
BOOST_DEDUCED_TYPENAME X::tname, choice1>::type \
test(choice1); \ test(choice1); \
\ \
template <typename X> \ template <typename X> \
@ -141,8 +136,7 @@ namespace boost { namespace unordered { namespace detail {
\ \
enum { value = (1 == sizeof(test<Tp>(choose()))) }; \ enum { value = (1 == sizeof(test<Tp>(choose()))) }; \
\ \
typedef BOOST_DEDUCED_TYPENAME \ typedef typename boost::detail::if_true<value>:: \
boost::detail::if_true<value>:: \
BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \ BOOST_NESTED_TEMPLATE then<Tp, DefaultWrap> \
::type::tname type; \ ::type::tname type; \
} }
@ -150,7 +144,7 @@ namespace boost { namespace unordered { namespace detail {
#endif #endif
#define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg) \ #define BOOST_UNORDERED_DEFAULT_TYPE(T,tname, arg) \
BOOST_DEDUCED_TYPENAME default_type_ ## tname<T, arg>::type typename default_type_ ## tname<T, arg>::type
BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer); BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(pointer);
BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer); BOOST_UNORDERED_DEFAULT_TYPE_TMPLT(const_pointer);
@ -228,7 +222,7 @@ namespace boost { namespace unordered { namespace detail {
typedef BOOST_PP_CAT(choice, result) type; \ typedef BOOST_PP_CAT(choice, result) type; \
}; \ }; \
\ \
template <class U> static BOOST_DEDUCED_TYPENAME \ template <class U> static typename \
BOOST_PP_CAT(test, count)<&U::name>::type \ BOOST_PP_CAT(test, count)<&U::name>::type \
test(BOOST_PP_CAT(choice, count)) test(BOOST_PP_CAT(choice, count))
@ -261,7 +255,7 @@ namespace boost { namespace unordered { namespace detail {
#endif #endif
template <typename Alloc> template <typename Alloc>
inline BOOST_DEDUCED_TYPENAME boost::enable_if< inline typename boost::enable_if<
has_select_on_container_copy_construction<Alloc>, Alloc has_select_on_container_copy_construction<Alloc>, Alloc
>::type call_select_on_container_copy_construction(const Alloc& rhs) >::type call_select_on_container_copy_construction(const Alloc& rhs)
{ {
@ -269,7 +263,7 @@ namespace boost { namespace unordered { namespace detail {
} }
template <typename Alloc> template <typename Alloc>
inline BOOST_DEDUCED_TYPENAME boost::disable_if< inline typename boost::disable_if<
has_select_on_container_copy_construction<Alloc>, Alloc has_select_on_container_copy_construction<Alloc>, Alloc
>::type call_select_on_container_copy_construction(const Alloc& rhs) >::type call_select_on_container_copy_construction(const Alloc& rhs)
{ {
@ -302,7 +296,7 @@ namespace boost { namespace unordered { namespace detail {
// For now always use the allocator's const_pointer. // For now always use the allocator's const_pointer.
//typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer, //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_pointer,
// BOOST_DEDUCED_TYPENAME pointer_traits<pointer>:: // typename pointer_traits<pointer>::
// BOOST_NESTED_TEMPLATE rebind<const value_type>::other) // BOOST_NESTED_TEMPLATE rebind<const value_type>::other)
// const_pointer; // const_pointer;
@ -317,7 +311,7 @@ namespace boost { namespace unordered { namespace detail {
// void_pointer; // void_pointer;
//typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer, //typedef BOOST_UNORDERED_DEFAULT_TYPE(Alloc, const_void_pointer,
// BOOST_DEDUCED_TYPENAME pointer_traits<pointer>:: // typename pointer_traits<pointer>::
// BOOST_NESTED_TEMPLATE rebind<const void>::other) // BOOST_NESTED_TEMPLATE rebind<const void>::other)
// const_void_pointer; // const_void_pointer;
@ -409,7 +403,7 @@ namespace boost { namespace unordered { namespace detail {
template <typename Allocator> template <typename Allocator>
struct allocator_array_constructor struct allocator_array_constructor
{ {
typedef BOOST_DEDUCED_TYPENAME allocator_traits<Allocator>::pointer typedef typename allocator_traits<Allocator>::pointer
pointer; pointer;
Allocator& alloc_; Allocator& alloc_;

61
include/boost/unordered/detail/buckets.hpp
View File

@ -41,7 +41,7 @@ namespace boost { namespace unordered { namespace detail {
public: public:
// Types // Types
typedef BOOST_DEDUCED_TYPENAME ::boost::detail::if_true<Unique>:: typedef typename ::boost::detail::if_true<Unique>::
BOOST_NESTED_TEMPLATE then< BOOST_NESTED_TEMPLATE then<
::boost::unordered::detail::ungrouped_node<A>, ::boost::unordered::detail::ungrouped_node<A>,
::boost::unordered::detail::grouped_node<A> ::boost::unordered::detail::grouped_node<A>
@ -49,16 +49,15 @@ namespace boost { namespace unordered { namespace detail {
typedef A value_allocator; typedef A value_allocator;
typedef ::boost::unordered::detail::bucket<A> bucket; typedef ::boost::unordered::detail::bucket<A> bucket;
typedef BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type value_type; typedef typename allocator_traits<A>::value_type value_type;
typedef BOOST_DEDUCED_TYPENAME bucket::bucket_allocator typedef typename bucket::bucket_allocator bucket_allocator;
bucket_allocator; typedef typename allocator_traits<bucket_allocator>::pointer bucket_ptr;
typedef BOOST_DEDUCED_TYPENAME allocator_traits<bucket_allocator>::pointer bucket_ptr; typedef typename bucket::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME rebind_wrap<value_allocator, node>::type typedef typename rebind_wrap<value_allocator, node>::type
node_allocator; node_allocator;
typedef BOOST_DEDUCED_TYPENAME allocator_traits<node_allocator>::pointer real_node_ptr; typedef typename allocator_traits<node_allocator>::pointer real_node_ptr;
// Members // Members
@ -423,7 +422,7 @@ namespace boost { namespace unordered { namespace detail {
functions& operator=(functions const&); functions& operator=(functions const&);
typedef compressed_pair<H, P> function_pair; typedef compressed_pair<H, P> function_pair;
typedef BOOST_DEDUCED_TYPENAME ::boost::aligned_storage< typedef typename ::boost::aligned_storage<
sizeof(function_pair), sizeof(function_pair),
::boost::alignment_of<function_pair>::value>::type aligned_function; ::boost::alignment_of<function_pair>::value>::type aligned_function;
@ -647,7 +646,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
} }
template <class T, class Arg1> template <class T, class Arg1>
inline BOOST_DEDUCED_TYPENAME normal_construct1<T, Arg1>::type inline typename normal_construct1<T, Arg1>::type
construct_impl(void* address, BOOST_FWD_REF(Arg1) arg1) construct_impl(void* address, BOOST_FWD_REF(Arg1) arg1)
{ {
new(address) T( new(address) T(
@ -656,14 +655,14 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
} }
template <class T, class Arg1> template <class T, class Arg1>
inline BOOST_DEDUCED_TYPENAME pair_construct1<T, Arg1>::type inline typename pair_construct1<T, Arg1>::type
construct_impl(void* address, BOOST_FWD_REF(Arg1) arg1) construct_impl(void* address, BOOST_FWD_REF(Arg1) arg1)
{ {
new((void*)(&static_cast<T*>(address)->first)) new((void*)(&static_cast<T*>(address)->first))
BOOST_DEDUCED_TYPENAME T::first_type( typename T::first_type(
boost::forward<Arg1>(arg1)); boost::forward<Arg1>(arg1));
new((void*)(&static_cast<T*>(address)->second)) new((void*)(&static_cast<T*>(address)->second))
BOOST_DEDUCED_TYPENAME T::second_type(); typename T::second_type();
} }
template <class T, class Arg1, class Arg2> template <class T, class Arg1, class Arg2>
@ -676,7 +675,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
} }
template <class T, class Arg1, class Arg2, class Arg3> template <class T, class Arg1, class Arg2, class Arg3>
inline BOOST_DEDUCED_TYPENAME piecewise_construct3<T, Arg1>::type inline typename piecewise_construct3<T, Arg1>::type
construct_impl(void* address, BOOST_FWD_REF(Arg1), construct_impl(void* address, BOOST_FWD_REF(Arg1),
BOOST_FWD_REF(Arg2) arg2, BOOST_FWD_REF(Arg3) arg3) BOOST_FWD_REF(Arg2) arg2, BOOST_FWD_REF(Arg3) arg3)
{ {
@ -685,21 +684,21 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
} }
template <class T, class Arg1, class Arg2, class Arg3> template <class T, class Arg1, class Arg2, class Arg3>
inline BOOST_DEDUCED_TYPENAME pair_construct3<T, Arg1>::type inline typename pair_construct3<T, Arg1>::type
construct_impl(void* address, BOOST_FWD_REF(Arg1) arg1, construct_impl(void* address, BOOST_FWD_REF(Arg1) arg1,
BOOST_FWD_REF(Arg2) arg2, BOOST_FWD_REF(Arg3) arg3) BOOST_FWD_REF(Arg2) arg2, BOOST_FWD_REF(Arg3) arg3)
{ {
new((void*)(&static_cast<T*>(address)->first)) new((void*)(&static_cast<T*>(address)->first))
BOOST_DEDUCED_TYPENAME T::first_type( typename T::first_type(
boost::forward<Arg1>(arg1)); boost::forward<Arg1>(arg1));
new((void*)(&static_cast<T*>(address)->second)) new((void*)(&static_cast<T*>(address)->second))
BOOST_DEDUCED_TYPENAME T::second_type( typename T::second_type(
boost::forward<Arg2>(arg2), boost::forward<Arg2>(arg2),
boost::forward<Arg3>(arg3)); boost::forward<Arg3>(arg3));
} }
template <class T, class Arg1, class Arg2, class Arg3> template <class T, class Arg1, class Arg2, class Arg3>
inline BOOST_DEDUCED_TYPENAME normal_construct3<T, Arg1>::type inline typename normal_construct3<T, Arg1>::type
construct_impl(void* address, BOOST_FWD_REF(Arg1) arg1, construct_impl(void* address, BOOST_FWD_REF(Arg1) arg1,
BOOST_FWD_REF(Arg2) arg2, BOOST_FWD_REF(Arg3) arg3) BOOST_FWD_REF(Arg2) arg2, BOOST_FWD_REF(Arg3) arg3)
{ {
@ -712,7 +711,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE) #if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
template <class T, class Arg1, class Arg2, class Arg3, class Arg4, class... Args> template <class T, class Arg1, class Arg2, class Arg3, class Arg4, class... Args>
inline BOOST_DEDUCED_TYPENAME normal_construct_n<T>::type inline typename normal_construct_n<T>::type
construct_impl(void* address, Arg1&& arg1, Arg2&& arg2, Arg3&& arg3, construct_impl(void* address, Arg1&& arg1, Arg2&& arg2, Arg3&& arg3,
Arg4&& arg4, Args&&... args) Arg4&& arg4, Args&&... args)
{ {
@ -725,15 +724,15 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
} }
template <class T, class Arg1, class Arg2, class Arg3, class Arg4, class... Args> template <class T, class Arg1, class Arg2, class Arg3, class Arg4, class... Args>
inline BOOST_DEDUCED_TYPENAME pair_construct_n<T>::type inline typename pair_construct_n<T>::type
construct_impl(void* address, Arg1&& arg1, Arg2&& arg2, Arg3&& arg3, construct_impl(void* address, Arg1&& arg1, Arg2&& arg2, Arg3&& arg3,
Arg4&& arg4, Args&&... args) Arg4&& arg4, Args&&... args)
{ {
new((void*)(&static_cast<T*>(address)->first)) new((void*)(&static_cast<T*>(address)->first))
BOOST_DEDUCED_TYPENAME T::first_type( typename T::first_type(
std::forward<Arg1>(arg1)); std::forward<Arg1>(arg1));
new((void*)(&static_cast<T*>(address)->second)) new((void*)(&static_cast<T*>(address)->second))
BOOST_DEDUCED_TYPENAME T::second_type( typename T::second_type(
std::forward<Arg2>(arg2), std::forward<Arg2>(arg2),
std::forward<Arg3>(arg3), std::forward<Arg3>(arg3),
std::forward<Arg4>(arg4), std::forward<Arg4>(arg4),
@ -747,7 +746,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
class T, \ class T, \
BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params) \
> \ > \
inline BOOST_DEDUCED_TYPENAME normal_construct_n<T>::type \ inline typename normal_construct_n<T>::type \
construct_impl(void* address, \ construct_impl(void* address, \
BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
{ \ { \
@ -762,15 +761,15 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
template <class T, class Key, \ template <class T, class Key, \
BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, num_params) \
> \ > \
inline BOOST_DEDUCED_TYPENAME pair_construct_n<T>::type \ inline typename pair_construct_n<T>::type \
construct_impl(void* address, BOOST_FWD_REF(Key) key, \ construct_impl(void* address, BOOST_FWD_REF(Key) key, \
BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, num_params)) \
{ \ { \
new((void*)(&static_cast<T*>(address)->first)) \ new((void*)(&static_cast<T*>(address)->first)) \
BOOST_DEDUCED_TYPENAME T::first_type( \ typename T::first_type( \
boost::forward<Key>(key)); \ boost::forward<Key>(key)); \
new((void*)(&static_cast<T*>(address)->second)) \ new((void*)(&static_cast<T*>(address)->second)) \
BOOST_DEDUCED_TYPENAME T::second_type( \ typename T::second_type( \
BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \ BOOST_UNORDERED_CALL_PARAMS(z, num_params)); \
} }
@ -788,10 +787,10 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
class node_constructor class node_constructor
{ {
typedef ::boost::unordered::detail::buckets<Alloc, Unique> buckets; typedef ::boost::unordered::detail::buckets<Alloc, Unique> buckets;
typedef BOOST_DEDUCED_TYPENAME buckets::node node; typedef typename buckets::node node;
typedef BOOST_DEDUCED_TYPENAME buckets::real_node_ptr real_node_ptr; typedef typename buckets::real_node_ptr real_node_ptr;
typedef BOOST_DEDUCED_TYPENAME buckets::value_type value_type; typedef typename buckets::value_type value_type;
typedef BOOST_DEDUCED_TYPENAME buckets::node_allocator node_allocator; typedef typename buckets::node_allocator node_allocator;
buckets& buckets_; buckets& buckets_;
real_node_ptr node_; real_node_ptr node_;
@ -858,7 +857,7 @@ BOOST_UNORDERED_CONSTRUCT_FROM_TUPLE(10, std::tr1)
} }
// no throw // no throw
BOOST_DEDUCED_TYPENAME buckets::node_ptr release() typename buckets::node_ptr release()
{ {
real_node_ptr p = node_; real_node_ptr p = node_;
node_ = real_node_ptr(); node_ = real_node_ptr();

39
include/boost/unordered/detail/equivalent.hpp
View File

@ -15,19 +15,19 @@ namespace boost { namespace unordered { namespace detail {
class equivalent_table : public T::table_base class equivalent_table : public T::table_base
{ {
public: public:
typedef BOOST_DEDUCED_TYPENAME T::hasher hasher; typedef typename T::hasher hasher;
typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal; typedef typename T::key_equal key_equal;
typedef BOOST_DEDUCED_TYPENAME T::value_allocator value_allocator; typedef typename T::value_allocator value_allocator;
typedef BOOST_DEDUCED_TYPENAME T::key_type key_type; typedef typename T::key_type key_type;
typedef BOOST_DEDUCED_TYPENAME T::value_type value_type; typedef typename T::value_type value_type;
typedef BOOST_DEDUCED_TYPENAME T::table_base table_base; typedef typename T::table_base table_base;
typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor; typedef typename T::node_constructor node_constructor;
typedef BOOST_DEDUCED_TYPENAME T::node_allocator node_allocator; typedef typename T::node_allocator node_allocator;
typedef BOOST_DEDUCED_TYPENAME T::node node; typedef typename T::node node;
typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr; typedef typename T::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME T::bucket_ptr bucket_ptr; typedef typename T::bucket_ptr bucket_ptr;
typedef BOOST_DEDUCED_TYPENAME T::extractor extractor; typedef typename T::extractor extractor;
// Constructors // Constructors
@ -298,19 +298,18 @@ namespace boost { namespace unordered { namespace detail {
template <class I> template <class I>
void insert_range(I i, I j) void insert_range(I i, I j)
{ {
BOOST_DEDUCED_TYPENAME ::boost::iterator_traversal<I>::type insert_for_range(i, j,
iterator_traversal_tag; BOOST_DEDUCED_TYPENAME ::boost::iterator_traversal<I>::type());
insert_for_range(i, j, iterator_traversal_tag);
} }
}; };
template <class H, class P, class A> template <class H, class P, class A>
struct multiset : public types< struct multiset : public types<
BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type, typename allocator_traits<A>::value_type,
BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type, typename allocator_traits<A>::value_type,
H, P, A, H, P, A,
set_extractor<BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type>, set_extractor<typename allocator_traits<A>::value_type>,
false> false>
{ {
typedef equivalent_table<multiset<H, P, A> > impl; typedef equivalent_table<multiset<H, P, A> > impl;
@ -319,9 +318,9 @@ namespace boost { namespace unordered { namespace detail {
template <class K, class H, class P, class A> template <class K, class H, class P, class A>
struct multimap : public types< struct multimap : public types<
K, BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type, K, typename allocator_traits<A>::value_type,
H, P, A, H, P, A,
map_extractor<K, BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type>, map_extractor<K, typename allocator_traits<A>::value_type>,
false> false>
{ {
typedef equivalent_table<multimap<K, H, P, A> > impl; typedef equivalent_table<multimap<K, H, P, A> > impl;

13
include/boost/unordered/detail/extract_key.hpp
View File

@ -35,8 +35,7 @@ namespace detail {
enum { value = sizeof(test(make<T>())) == sizeof(choice2::type) }; enum { value = sizeof(test(make<T>())) == sizeof(choice2::type) };
typedef BOOST_DEDUCED_TYPENAME typedef typename boost::detail::if_true<value>::
boost::detail::if_true<value>::
BOOST_NESTED_TEMPLATE then<Key const&, no_key>::type type; BOOST_NESTED_TEMPLATE then<Key const&, no_key>::type type;
}; };
@ -94,7 +93,7 @@ namespace detail {
struct map_extractor struct map_extractor
{ {
typedef ValueType value_type; typedef ValueType value_type;
typedef BOOST_DEDUCED_TYPENAME ::boost::remove_const<Key>::type key_type; typedef typename ::boost::remove_const<Key>::type key_type;
static key_type const& extract(value_type const& v) static key_type const& extract(value_type const& v)
{ {
@ -176,11 +175,11 @@ namespace detail {
} \ } \
\ \
template <typename T, typename T2> \ template <typename T, typename T2> \
static BOOST_DEDUCED_TYPENAME is_key<key_type, T>::type \ static typename is_key<key_type, T>::type \
extract(boost::unordered::piecewise_construct_t, \ extract(boost::unordered::piecewise_construct_t, \
namespace_::tuple<T> const& k, T2&&) \ namespace_::tuple<T> const& k, T2&&) \
{ \ { \
return BOOST_DEDUCED_TYPENAME is_key<key_type, T>::type( \ return typename is_key<key_type, T>::type( \
namespace_::get<0>(k)); \ namespace_::get<0>(k)); \
} }
@ -194,11 +193,11 @@ namespace detail {
} \ } \
\ \
template <typename T> \ template <typename T> \
static BOOST_DEDUCED_TYPENAME is_key<key_type, T>::type \ static typename is_key<key_type, T>::type \
extract(boost::unordered::piecewise_construct_t, \ extract(boost::unordered::piecewise_construct_t, \
namespace_::tuple<T> const& k) \ namespace_::tuple<T> const& k) \
{ \ { \
return BOOST_DEDUCED_TYPENAME is_key<key_type, T>::type( \ return typename is_key<key_type, T>::type( \
namespace_::get<0>(k)); \ namespace_::get<0>(k)); \
} }

24
include/boost/unordered/detail/node.hpp
View File

@ -59,11 +59,9 @@ namespace boost { namespace unordered { namespace detail {
{ {
bucket& operator=(bucket const&); bucket& operator=(bucket const&);
public: public:
typedef BOOST_DEDUCED_TYPENAME typedef typename ::boost::unordered::detail::rebind_wrap<A, bucket>::type
::boost::unordered::detail::rebind_wrap<A, bucket>::type
bucket_allocator; bucket_allocator;
typedef BOOST_DEDUCED_TYPENAME typedef typename allocator_traits<bucket_allocator>::pointer bucket_ptr;
allocator_traits<bucket_allocator>::pointer bucket_ptr;
typedef bucket_ptr node_ptr; typedef bucket_ptr node_ptr;
node_ptr next_; node_ptr next_;
@ -77,7 +75,7 @@ namespace boost { namespace unordered { namespace detail {
struct value_base struct value_base
{ {
typedef ValueType value_type; typedef ValueType value_type;
BOOST_DEDUCED_TYPENAME ::boost::aligned_storage< typename ::boost::aligned_storage<
sizeof(value_type), sizeof(value_type),
::boost::alignment_of<value_type>::value>::type data_; ::boost::alignment_of<value_type>::value>::type data_;
@ -107,12 +105,12 @@ namespace boost { namespace unordered { namespace detail {
template <class A> template <class A>
struct ungrouped_node struct ungrouped_node
: ::boost::unordered::detail::bucket<A>, : ::boost::unordered::detail::bucket<A>,
value_base<BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type> value_base<typename allocator_traits<A>::value_type>
{ {
typedef ::boost::unordered::detail::bucket<A> bucket; typedef ::boost::unordered::detail::bucket<A> bucket;
typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr; typedef typename bucket::bucket_ptr bucket_ptr;
typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr; typedef typename bucket::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type value_type; typedef typename allocator_traits<A>::value_type value_type;
std::size_t hash_; std::size_t hash_;
@ -182,12 +180,12 @@ namespace boost { namespace unordered { namespace detail {
template <class A> template <class A>
struct grouped_node struct grouped_node
: ::boost::unordered::detail::bucket<A>, : ::boost::unordered::detail::bucket<A>,
value_base<BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type> value_base<typename allocator_traits<A>::value_type>
{ {
typedef ::boost::unordered::detail::bucket<A> bucket; typedef ::boost::unordered::detail::bucket<A> bucket;
typedef BOOST_DEDUCED_TYPENAME bucket::bucket_ptr bucket_ptr; typedef typename bucket::bucket_ptr bucket_ptr;
typedef BOOST_DEDUCED_TYPENAME bucket::node_ptr node_ptr; typedef typename bucket::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type value_type; typedef typename allocator_traits<A>::value_type value_type;
std::size_t hash_; std::size_t hash_;
node_ptr group_prev_; node_ptr group_prev_;

96
include/boost/unordered/detail/table.hpp
View File

@ -23,22 +23,22 @@ namespace boost { namespace unordered { namespace detail {
table(table const&); table(table const&);
table& operator=(table const&); table& operator=(table const&);
public: public:
typedef BOOST_DEDUCED_TYPENAME T::hasher hasher; typedef typename T::hasher hasher;
typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal; typedef typename T::key_equal key_equal;
typedef BOOST_DEDUCED_TYPENAME T::value_allocator value_allocator; typedef typename T::value_allocator value_allocator;
typedef BOOST_DEDUCED_TYPENAME T::key_type key_type; typedef typename T::key_type key_type;
typedef BOOST_DEDUCED_TYPENAME T::value_type value_type; typedef typename T::value_type value_type;
typedef BOOST_DEDUCED_TYPENAME T::functions functions; typedef typename T::functions functions;
typedef BOOST_DEDUCED_TYPENAME T::buckets buckets; typedef typename T::buckets buckets;
typedef BOOST_DEDUCED_TYPENAME T::extractor extractor; typedef typename T::extractor extractor;
typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor; typedef typename T::node_constructor node_constructor;
typedef BOOST_DEDUCED_TYPENAME T::node node; typedef typename T::node node;
typedef BOOST_DEDUCED_TYPENAME T::bucket bucket; typedef typename T::bucket bucket;
typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr; typedef typename T::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME T::bucket_ptr bucket_ptr; typedef typename T::bucket_ptr bucket_ptr;
typedef BOOST_DEDUCED_TYPENAME T::node_allocator node_allocator; typedef typename T::node_allocator node_allocator;
typedef BOOST_DEDUCED_TYPENAME T::iterator_pair iterator_pair; typedef typename T::iterator_pair iterator_pair;
// Members // Members
@ -485,11 +485,11 @@ namespace boost { namespace unordered { namespace detail {
typedef ::boost::unordered::detail::buckets<value_allocator, Unique> buckets; typedef ::boost::unordered::detail::buckets<value_allocator, Unique> buckets;
typedef ::boost::unordered::detail::functions<hasher, key_equal> functions; typedef ::boost::unordered::detail::functions<hasher, key_equal> functions;
typedef BOOST_DEDUCED_TYPENAME buckets::node node; typedef typename buckets::node node;
typedef BOOST_DEDUCED_TYPENAME buckets::bucket bucket; typedef typename buckets::bucket bucket;
typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr node_ptr; typedef typename buckets::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME buckets::bucket_ptr bucket_ptr; typedef typename buckets::bucket_ptr bucket_ptr;
typedef BOOST_DEDUCED_TYPENAME buckets::node_allocator node_allocator; typedef typename buckets::node_allocator node_allocator;
typedef std::pair<node_ptr, node_ptr> iterator_pair; typedef std::pair<node_ptr, node_ptr> iterator_pair;
}; };
@ -514,18 +514,18 @@ namespace boost { namespace unordered { namespace iterator_detail {
class l_iterator class l_iterator
: public ::boost::iterator < : public ::boost::iterator <
std::forward_iterator_tag, std::forward_iterator_tag,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type, typename boost::unordered::detail::allocator_traits<A>::value_type,
std::ptrdiff_t, std::ptrdiff_t,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::pointer, typename boost::unordered::detail::allocator_traits<A>::pointer,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type&> typename boost::unordered::detail::allocator_traits<A>::value_type&>
{ {
public: public:
typedef BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type value_type; typedef typename boost::unordered::detail::allocator_traits<A>::value_type value_type;
private: private:
typedef ::boost::unordered::detail::buckets<A, Unique> buckets; typedef ::boost::unordered::detail::buckets<A, Unique> buckets;
typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr node_ptr; typedef typename buckets::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME buckets::node node; typedef typename buckets::node node;
typedef cl_iterator<A, Unique> const_local_iterator; typedef cl_iterator<A, Unique> const_local_iterator;
friend class cl_iterator<A, Unique>; friend class cl_iterator<A, Unique>;
@ -538,7 +538,7 @@ namespace boost { namespace unordered { namespace iterator_detail {
l_iterator() : ptr_() {} l_iterator() : ptr_() {}
l_iterator(node_ptr x, std::size_t b, std::size_t c) l_iterator(node_ptr x, std::size_t b, std::size_t c)
: ptr_(x), bucket_(b), bucket_count_(c) {} : ptr_(x), bucket_(b), bucket_count_(c) {}
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type& operator*() const { typename boost::unordered::detail::allocator_traits<A>::value_type& operator*() const {
return node::get_value(ptr_); return node::get_value(ptr_);
} }
value_type* operator->() const { value_type* operator->() const {
@ -575,18 +575,18 @@ namespace boost { namespace unordered { namespace iterator_detail {
class cl_iterator class cl_iterator
: public ::boost::iterator < : public ::boost::iterator <
std::forward_iterator_tag, std::forward_iterator_tag,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type, typename boost::unordered::detail::allocator_traits<A>::value_type,
std::ptrdiff_t, std::ptrdiff_t,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::const_pointer, typename boost::unordered::detail::allocator_traits<A>::const_pointer,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type const& > typename boost::unordered::detail::allocator_traits<A>::value_type const& >
{ {
public: public:
typedef BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type value_type; typedef typename boost::unordered::detail::allocator_traits<A>::value_type value_type;
private: private:
typedef ::boost::unordered::detail::buckets<A, Unique> buckets; typedef ::boost::unordered::detail::buckets<A, Unique> buckets;
typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr node_ptr; typedef typename buckets::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME buckets::node node; typedef typename buckets::node node;
typedef l_iterator<A, Unique> local_iterator; typedef l_iterator<A, Unique> local_iterator;
friend class l_iterator<A, Unique>; friend class l_iterator<A, Unique>;
@ -602,7 +602,7 @@ namespace boost { namespace unordered { namespace iterator_detail {
cl_iterator(local_iterator x) cl_iterator(local_iterator x)
: ptr_(x.ptr_), bucket_(x.bucket_), bucket_count_(x.bucket_count_) : ptr_(x.ptr_), bucket_(x.bucket_), bucket_count_(x.bucket_count_)
{} {}
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type const& typename boost::unordered::detail::allocator_traits<A>::value_type const&
operator*() const { operator*() const {
return node::get_value(ptr_); return node::get_value(ptr_);
} }
@ -640,18 +640,18 @@ namespace boost { namespace unordered { namespace iterator_detail {
class iterator class iterator
: public ::boost::iterator < : public ::boost::iterator <
std::forward_iterator_tag, std::forward_iterator_tag,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type, typename boost::unordered::detail::allocator_traits<A>::value_type,
std::ptrdiff_t, std::ptrdiff_t,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::pointer, typename boost::unordered::detail::allocator_traits<A>::pointer,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type& > typename boost::unordered::detail::allocator_traits<A>::value_type& >
{ {
public: public:
typedef BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type value_type; typedef typename boost::unordered::detail::allocator_traits<A>::value_type value_type;
private: private:
typedef ::boost::unordered::detail::buckets<A, Unique> buckets; typedef ::boost::unordered::detail::buckets<A, Unique> buckets;
typedef BOOST_DEDUCED_TYPENAME buckets::node node; typedef typename buckets::node node;
typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr node_ptr; typedef typename buckets::node_ptr node_ptr;
typedef c_iterator<A, Unique> const_iterator; typedef c_iterator<A, Unique> const_iterator;
friend class c_iterator<A, Unique>; friend class c_iterator<A, Unique>;
node_ptr node_; node_ptr node_;
@ -660,7 +660,7 @@ namespace boost { namespace unordered { namespace iterator_detail {
iterator() : node_() {} iterator() : node_() {}
explicit iterator(node_ptr const& x) : node_(x) {} explicit iterator(node_ptr const& x) : node_(x) {}
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type& operator*() const { typename boost::unordered::detail::allocator_traits<A>::value_type& operator*() const {
return node::get_value(node_); return node::get_value(node_);
} }
value_type* operator->() const { value_type* operator->() const {
@ -690,18 +690,18 @@ namespace boost { namespace unordered { namespace iterator_detail {
class c_iterator class c_iterator
: public ::boost::iterator < : public ::boost::iterator <
std::forward_iterator_tag, std::forward_iterator_tag,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type, typename boost::unordered::detail::allocator_traits<A>::value_type,
std::ptrdiff_t, std::ptrdiff_t,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::const_pointer, typename boost::unordered::detail::allocator_traits<A>::const_pointer,
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type const& > typename boost::unordered::detail::allocator_traits<A>::value_type const& >
{ {
public: public:
typedef BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type value_type; typedef typename boost::unordered::detail::allocator_traits<A>::value_type value_type;
private: private:
typedef ::boost::unordered::detail::buckets<A, Unique> buckets; typedef ::boost::unordered::detail::buckets<A, Unique> buckets;
typedef BOOST_DEDUCED_TYPENAME buckets::node node; typedef typename buckets::node node;
typedef BOOST_DEDUCED_TYPENAME buckets::node_ptr node_ptr; typedef typename buckets::node_ptr node_ptr;
typedef ::boost::unordered::iterator_detail::iterator<A, Unique> typedef ::boost::unordered::iterator_detail::iterator<A, Unique>
iterator; iterator;
friend class ::boost::unordered::iterator_detail::iterator<A, Unique>; friend class ::boost::unordered::iterator_detail::iterator<A, Unique>;
@ -726,7 +726,7 @@ namespace boost { namespace unordered { namespace iterator_detail {
c_iterator() : node_() {} c_iterator() : node_() {}
explicit c_iterator(node_ptr const& x) : node_(x) {} explicit c_iterator(node_ptr const& x) : node_(x) {}
c_iterator(iterator const& x) : node_(x.node_) {} c_iterator(iterator const& x) : node_(x.node_) {}
BOOST_DEDUCED_TYPENAME boost::unordered::detail::allocator_traits<A>::value_type const& operator*() const { typename boost::unordered::detail::allocator_traits<A>::value_type const& operator*() const {
return node::get_value(node_); return node::get_value(node_);
} }
value_type const* operator->() const { value_type const* operator->() const {

36
include/boost/unordered/detail/unique.hpp
View File

@ -15,19 +15,19 @@ namespace boost { namespace unordered { namespace detail {
class unique_table : public T::table_base class unique_table : public T::table_base
{ {
public: public:
typedef BOOST_DEDUCED_TYPENAME T::hasher hasher; typedef typename T::hasher hasher;
typedef BOOST_DEDUCED_TYPENAME T::key_equal key_equal; typedef typename T::key_equal key_equal;
typedef BOOST_DEDUCED_TYPENAME T::value_allocator value_allocator; typedef typename T::value_allocator value_allocator;
typedef BOOST_DEDUCED_TYPENAME T::key_type key_type; typedef typename T::key_type key_type;
typedef BOOST_DEDUCED_TYPENAME T::value_type value_type; typedef typename T::value_type value_type;
typedef BOOST_DEDUCED_TYPENAME T::table_base table_base; typedef typename T::table_base table_base;
typedef BOOST_DEDUCED_TYPENAME T::node_constructor node_constructor; typedef typename T::node_constructor node_constructor;
typedef BOOST_DEDUCED_TYPENAME T::node_allocator node_allocator; typedef typename T::node_allocator node_allocator;
typedef BOOST_DEDUCED_TYPENAME T::node node; typedef typename T::node node;
typedef BOOST_DEDUCED_TYPENAME T::node_ptr node_ptr; typedef typename T::node_ptr node_ptr;
typedef BOOST_DEDUCED_TYPENAME T::bucket_ptr bucket_ptr; typedef typename T::bucket_ptr bucket_ptr;
typedef BOOST_DEDUCED_TYPENAME T::extractor extractor; typedef typename T::extractor extractor;
typedef std::pair<node_ptr, bool> emplace_return; typedef std::pair<node_ptr, bool> emplace_return;
@ -118,7 +118,7 @@ namespace boost { namespace unordered { namespace detail {
value_type& operator[](key_type const& k) value_type& operator[](key_type const& k)
{ {
typedef BOOST_DEDUCED_TYPENAME value_type::second_type mapped_type; typedef typename value_type::second_type mapped_type;
std::size_t hash = this->hash_function()(k); std::size_t hash = this->hash_function()(k);
std::size_t bucket_index = hash % this->bucket_count_; std::size_t bucket_index = hash % this->bucket_count_;
@ -399,10 +399,10 @@ namespace boost { namespace unordered { namespace detail {
template <class H, class P, class A> template <class H, class P, class A>
struct set : public types< struct set : public types<
BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type, typename allocator_traits<A>::value_type,
BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type, typename allocator_traits<A>::value_type,
H, P, A, H, P, A,
set_extractor<BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type>, set_extractor<typename allocator_traits<A>::value_type>,
true> true>
{ {
typedef ::boost::unordered::detail::unique_table<set<H, P, A> > impl; typedef ::boost::unordered::detail::unique_table<set<H, P, A> > impl;
@ -411,9 +411,9 @@ namespace boost { namespace unordered { namespace detail {
template <class K, class H, class P, class A> template <class K, class H, class P, class A>
struct map : public types< struct map : public types<
K, BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type, K, typename allocator_traits<A>::value_type,
H, P, A, H, P, A,
map_extractor<K, BOOST_DEDUCED_TYPENAME allocator_traits<A>::value_type>, map_extractor<K, typename allocator_traits<A>::value_type>,
true> true>
{ {
typedef ::boost::unordered::detail::unique_table<map<K, H, P, A> > impl; typedef ::boost::unordered::detail::unique_table<map<K, H, P, A> > impl;

6
include/boost/unordered/detail/util.hpp
View File

@ -234,7 +234,7 @@ namespace boost { namespace unordered { namespace detail {
inline std::size_t insert_size(I i, I j) inline std::size_t insert_size(I i, I j)
{ {
return insert_size(i, j, return insert_size(i, j,
BOOST_DEDUCED_TYPENAME ::boost::iterator_traversal<I>::type()); typename ::boost::iterator_traversal<I>::type());
} }
template <class I> template <class I>
@ -285,8 +285,8 @@ namespace boost { namespace unordered { namespace detail {
: private generate_base<T1, 1>::type, : private generate_base<T1, 1>::type,
private generate_base<T2, 2>::type private generate_base<T2, 2>::type
{ {
typedef BOOST_DEDUCED_TYPENAME generate_base<T1, 1>::type base1; typedef typename generate_base<T1, 1>::type base1;
typedef BOOST_DEDUCED_TYPENAME generate_base<T2, 2>::type base2; typedef typename generate_base<T2, 2>::type base2;
typedef T1 first_type; typedef T1 first_type;
typedef T2 second_type; typedef T2 second_type;

134
include/boost/unordered/unordered_map.hpp
View File

@ -52,24 +52,21 @@ namespace unordered
private: private:
#endif #endif
typedef BOOST_DEDUCED_TYPENAME typedef typename ::boost::unordered::detail::rebind_wrap<
::boost::unordered::detail::rebind_wrap<
allocator_type, value_type>::type allocator_type, value_type>::type
value_allocator; value_allocator;
typedef ::boost::unordered::detail::allocator_traits<value_allocator> allocator_traits; typedef ::boost::unordered::detail::allocator_traits<value_allocator> allocator_traits;
typedef ::boost::unordered::detail::map<K, H, P, typedef ::boost::unordered::detail::map<K, H, P,
value_allocator> types; value_allocator> types;
typedef BOOST_DEDUCED_TYPENAME types::impl table; typedef typename types::impl table;
typedef BOOST_DEDUCED_TYPENAME types::node_ptr node_ptr; typedef typename types::node_ptr node_ptr;
public: public:
typedef BOOST_DEDUCED_TYPENAME typedef typename allocator_traits::pointer pointer;
allocator_traits::pointer pointer; typedef typename allocator_traits::const_pointer const_pointer;
typedef BOOST_DEDUCED_TYPENAME
allocator_traits::const_pointer const_pointer;
typedef value_type& reference; typedef value_type& reference;
typedef value_type const& const_reference; typedef value_type const& const_reference;
@ -403,8 +400,7 @@ namespace unordered
private: private:
#endif #endif
typedef BOOST_DEDUCED_TYPENAME typedef typename ::boost::unordered::detail::rebind_wrap<
::boost::unordered::detail::rebind_wrap<
allocator_type, value_type>::type allocator_type, value_type>::type
value_allocator; value_allocator;
typedef ::boost::unordered::detail::allocator_traits<value_allocator> typedef ::boost::unordered::detail::allocator_traits<value_allocator>
@ -412,16 +408,14 @@ namespace unordered
typedef ::boost::unordered::detail::multimap<K, H, P, typedef ::boost::unordered::detail::multimap<K, H, P,
value_allocator> types; value_allocator> types;
typedef BOOST_DEDUCED_TYPENAME types::impl table; typedef typename types::impl table;
typedef BOOST_DEDUCED_TYPENAME types::node_ptr node_ptr; typedef typename types::node_ptr node_ptr;
public: public:
typedef BOOST_DEDUCED_TYPENAME typedef typename allocator_traits::pointer pointer;
allocator_traits::pointer pointer; typedef typename allocator_traits::const_pointer const_pointer;
typedef BOOST_DEDUCED_TYPENAME
allocator_traits::const_pointer const_pointer;
typedef value_type& reference; typedef value_type& reference;
typedef value_type const& const_reference; typedef value_type const& const_reference;
@ -851,7 +845,7 @@ namespace unordered
#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE) #if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
template <class... Args> template <class... Args>
std::pair<BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator, bool> std::pair<typename unordered_map<K,T,H,P,A>::iterator, bool>
unordered_map<K,T,H,P,A>::emplace(Args&&... args) unordered_map<K,T,H,P,A>::emplace(Args&&... args)
{ {
return table_.emplace(std::forward<Args>(args)...); return table_.emplace(std::forward<Args>(args)...);
@ -859,7 +853,7 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
template <class... Args> template <class... Args>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator typename unordered_map<K,T,H,P,A>::iterator
unordered_map<K,T,H,P,A>::emplace_hint(const_iterator, Args&&... args) unordered_map<K,T,H,P,A>::emplace_hint(const_iterator, Args&&... args)
{ {
return iterator(table_.emplace(std::forward<Args>(args)...).first); return iterator(table_.emplace(std::forward<Args>(args)...).first);
@ -868,7 +862,7 @@ namespace unordered
#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100)) #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
std::pair<BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator, bool> std::pair<typename unordered_map<K,T,H,P,A>::iterator, bool>
unordered_map<K,T,H,P,A>::emplace( unordered_map<K,T,H,P,A>::emplace(
boost::unordered::detail::empty_emplace, boost::unordered::detail::empty_emplace,
value_type v value_type v
@ -878,7 +872,7 @@ namespace unordered
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator typename unordered_map<K,T,H,P,A>::iterator
unordered_map<K,T,H,P,A>::emplace_hint(const_iterator, unordered_map<K,T,H,P,A>::emplace_hint(const_iterator,
boost::unordered::detail::empty_emplace, boost::unordered::detail::empty_emplace,
value_type v value_type v
@ -893,9 +887,7 @@ namespace unordered
template < \ template < \
BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
> \ > \
std::pair< \ std::pair<typename unordered_map<K,T,H,P,A>::iterator, bool> \
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator, \
bool> \
unordered_map<K,T,H,P,A>::emplace( \ unordered_map<K,T,H,P,A>::emplace( \
BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
{ \ { \
@ -906,7 +898,7 @@ namespace unordered
template < \ template < \
BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
> \ > \
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator \ typename unordered_map<K,T,H,P,A>::iterator \
unordered_map<K,T,H,P,A>::emplace_hint( \ unordered_map<K,T,H,P,A>::emplace_hint( \
const_iterator, \ const_iterator, \
BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
@ -924,14 +916,14 @@ namespace unordered
#endif #endif
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
std::pair<BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator, bool> std::pair<typename unordered_map<K,T,H,P,A>::iterator, bool>
unordered_map<K,T,H,P,A>::insert(value_type const& obj) unordered_map<K,T,H,P,A>::insert(value_type const& obj)
{ {
return table_.emplace(obj); return table_.emplace(obj);
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator typename unordered_map<K,T,H,P,A>::iterator
unordered_map<K,T,H,P,A>::insert(const_iterator, unordered_map<K,T,H,P,A>::insert(const_iterator,
value_type const& obj) value_type const& obj)
{ {
@ -940,14 +932,14 @@ namespace unordered
#if BOOST_UNORDERED_USE_RV_REF #if BOOST_UNORDERED_USE_RV_REF
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
std::pair<BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator, bool> std::pair<typename unordered_map<K,T,H,P,A>::iterator, bool>
unordered_map<K,T,H,P,A>::insert(BOOST_RV_REF(value_type) obj) unordered_map<K,T,H,P,A>::insert(BOOST_RV_REF(value_type) obj)
{ {
return table_.emplace(boost::move(obj)); return table_.emplace(boost::move(obj));
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator typename unordered_map<K,T,H,P,A>::iterator
unordered_map<K,T,H,P,A>::insert(const_iterator, unordered_map<K,T,H,P,A>::insert(const_iterator,
BOOST_RV_REF(value_type) obj) BOOST_RV_REF(value_type) obj)
{ {
@ -972,21 +964,21 @@ namespace unordered
#endif #endif
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator typename unordered_map<K,T,H,P,A>::iterator
unordered_map<K,T,H,P,A>::erase(const_iterator position) unordered_map<K,T,H,P,A>::erase(const_iterator position)
{ {
return iterator(table_.erase(position.node_)); return iterator(table_.erase(position.node_));
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::size_type typename unordered_map<K,T,H,P,A>::size_type
unordered_map<K,T,H,P,A>::erase(const key_type& k) unordered_map<K,T,H,P,A>::erase(const key_type& k)
{ {
return table_.erase_key(k); return table_.erase_key(k);
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator typename unordered_map<K,T,H,P,A>::iterator
unordered_map<K,T,H,P,A>::erase( unordered_map<K,T,H,P,A>::erase(
const_iterator first, const_iterator last) const_iterator first, const_iterator last)
{ {
@ -1008,35 +1000,35 @@ namespace unordered
// observers // observers
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::hasher typename unordered_map<K,T,H,P,A>::hasher
unordered_map<K,T,H,P,A>::hash_function() const unordered_map<K,T,H,P,A>::hash_function() const
{ {
return table_.hash_function(); return table_.hash_function();
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::key_equal typename unordered_map<K,T,H,P,A>::key_equal
unordered_map<K,T,H,P,A>::key_eq() const unordered_map<K,T,H,P,A>::key_eq() const
{ {
return table_.key_eq(); return table_.key_eq();
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::mapped_type& typename unordered_map<K,T,H,P,A>::mapped_type&
unordered_map<K,T,H,P,A>::operator[](const key_type &k) unordered_map<K,T,H,P,A>::operator[](const key_type &k)
{ {
return table_[k].second; return table_[k].second;
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::mapped_type& typename unordered_map<K,T,H,P,A>::mapped_type&
unordered_map<K,T,H,P,A>::at(const key_type& k) unordered_map<K,T,H,P,A>::at(const key_type& k)
{ {
return table_.at(k).second; return table_.at(k).second;
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::mapped_type const& typename unordered_map<K,T,H,P,A>::mapped_type const&
unordered_map<K,T,H,P,A>::at(const key_type& k) const unordered_map<K,T,H,P,A>::at(const key_type& k) const
{ {
return table_.at(k).second; return table_.at(k).second;
@ -1045,14 +1037,14 @@ namespace unordered
// lookup // lookup
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator typename unordered_map<K,T,H,P,A>::iterator
unordered_map<K,T,H,P,A>::find(const key_type& k) unordered_map<K,T,H,P,A>::find(const key_type& k)
{ {
return iterator(table_.find_node(k)); return iterator(table_.find_node(k));
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::const_iterator typename unordered_map<K,T,H,P,A>::const_iterator
unordered_map<K,T,H,P,A>::find(const key_type& k) const unordered_map<K,T,H,P,A>::find(const key_type& k) const
{ {
return const_iterator(table_.find_node(k)); return const_iterator(table_.find_node(k));
@ -1061,7 +1053,7 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
template <class CompatibleKey, class CompatibleHash, template <class CompatibleKey, class CompatibleHash,
class CompatiblePredicate> class CompatiblePredicate>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator typename unordered_map<K,T,H,P,A>::iterator
unordered_map<K,T,H,P,A>::find( unordered_map<K,T,H,P,A>::find(
CompatibleKey const& k, CompatibleKey const& k,
CompatibleHash const& hash, CompatibleHash const& hash,
@ -1073,7 +1065,7 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
template <class CompatibleKey, class CompatibleHash, template <class CompatibleKey, class CompatibleHash,
class CompatiblePredicate> class CompatiblePredicate>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::const_iterator typename unordered_map<K,T,H,P,A>::const_iterator
unordered_map<K,T,H,P,A>::find( unordered_map<K,T,H,P,A>::find(
CompatibleKey const& k, CompatibleKey const& k,
CompatibleHash const& hash, CompatibleHash const& hash,
@ -1083,7 +1075,7 @@ namespace unordered
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::size_type typename unordered_map<K,T,H,P,A>::size_type
unordered_map<K,T,H,P,A>::count(const key_type& k) const unordered_map<K,T,H,P,A>::count(const key_type& k) const
{ {
return table_.count(k); return table_.count(k);
@ -1091,8 +1083,8 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
std::pair< std::pair<
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator, typename unordered_map<K,T,H,P,A>::iterator,
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::iterator> typename unordered_map<K,T,H,P,A>::iterator>
unordered_map<K,T,H,P,A>::equal_range(const key_type& k) unordered_map<K,T,H,P,A>::equal_range(const key_type& k)
{ {
return table_.equal_range(k); return table_.equal_range(k);
@ -1100,15 +1092,15 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
std::pair< std::pair<
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::const_iterator, typename unordered_map<K,T,H,P,A>::const_iterator,
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::const_iterator> typename unordered_map<K,T,H,P,A>::const_iterator>
unordered_map<K,T,H,P,A>::equal_range(const key_type& k) const unordered_map<K,T,H,P,A>::equal_range(const key_type& k) const
{ {
return table_.equal_range(k); return table_.equal_range(k);
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_map<K,T,H,P,A>::size_type typename unordered_map<K,T,H,P,A>::size_type
unordered_map<K,T,H,P,A>::bucket_size(size_type n) const unordered_map<K,T,H,P,A>::bucket_size(size_type n) const
{ {
return table_.bucket_size(n); return table_.bucket_size(n);
@ -1284,7 +1276,7 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
template <class... Args> template <class... Args>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::emplace(Args&&... args) unordered_multimap<K,T,H,P,A>::emplace(Args&&... args)
{ {
return iterator(table_.emplace(std::forward<Args>(args)...)); return iterator(table_.emplace(std::forward<Args>(args)...));
@ -1292,7 +1284,7 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
template <class... Args> template <class... Args>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::emplace_hint( unordered_multimap<K,T,H,P,A>::emplace_hint(
const_iterator, Args&&... args) const_iterator, Args&&... args)
{ {
@ -1303,7 +1295,7 @@ namespace unordered
#if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100)) #if !BOOST_WORKAROUND(__SUNPRO_CC, BOOST_TESTED_AT(0x5100))
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::emplace( unordered_multimap<K,T,H,P,A>::emplace(
boost::unordered::detail::empty_emplace, boost::unordered::detail::empty_emplace,
value_type v value_type v
@ -1313,7 +1305,7 @@ namespace unordered
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::emplace_hint(const_iterator, unordered_multimap<K,T,H,P,A>::emplace_hint(const_iterator,
boost::unordered::detail::empty_emplace, boost::unordered::detail::empty_emplace,
value_type v value_type v
@ -1328,7 +1320,7 @@ namespace unordered
template < \ template < \
BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
> \ > \
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator \ typename unordered_multimap<K,T,H,P,A>::iterator \
unordered_multimap<K,T,H,P,A>::emplace( \ unordered_multimap<K,T,H,P,A>::emplace( \
BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
{ \ { \
@ -1340,7 +1332,7 @@ namespace unordered
template < \ template < \
BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
> \ > \
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator \ typename unordered_multimap<K,T,H,P,A>::iterator \
unordered_multimap<K,T,H,P,A>::emplace_hint( \ unordered_multimap<K,T,H,P,A>::emplace_hint( \
const_iterator, \ const_iterator, \
BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
@ -1357,14 +1349,14 @@ namespace unordered
#endif #endif
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::insert(value_type const& obj) unordered_multimap<K,T,H,P,A>::insert(value_type const& obj)
{ {
return iterator(table_.emplace(obj)); return iterator(table_.emplace(obj));
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::insert( unordered_multimap<K,T,H,P,A>::insert(
const_iterator, value_type const& obj) const_iterator, value_type const& obj)
{ {
@ -1373,14 +1365,14 @@ namespace unordered
#if BOOST_UNORDERED_USE_RV_REF #if BOOST_UNORDERED_USE_RV_REF
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::insert(BOOST_RV_REF(value_type) obj) unordered_multimap<K,T,H,P,A>::insert(BOOST_RV_REF(value_type) obj)
{ {
return iterator(table_.emplace(boost::move(obj))); return iterator(table_.emplace(boost::move(obj)));
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::insert( unordered_multimap<K,T,H,P,A>::insert(
const_iterator, BOOST_RV_REF(value_type) obj) const_iterator, BOOST_RV_REF(value_type) obj)
{ {
@ -1405,21 +1397,21 @@ namespace unordered
#endif #endif
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::erase(const_iterator position) unordered_multimap<K,T,H,P,A>::erase(const_iterator position)
{ {
return iterator(table_.erase(position.node_)); return iterator(table_.erase(position.node_));
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::size_type typename unordered_multimap<K,T,H,P,A>::size_type
unordered_multimap<K,T,H,P,A>::erase(const key_type& k) unordered_multimap<K,T,H,P,A>::erase(const key_type& k)
{ {
return table_.erase_key(k); return table_.erase_key(k);
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::erase( unordered_multimap<K,T,H,P,A>::erase(
const_iterator first, const_iterator last) const_iterator first, const_iterator last)
{ {
@ -1441,14 +1433,14 @@ namespace unordered
// observers // observers
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::hasher typename unordered_multimap<K,T,H,P,A>::hasher
unordered_multimap<K,T,H,P,A>::hash_function() const unordered_multimap<K,T,H,P,A>::hash_function() const
{ {
return table_.hash_function(); return table_.hash_function();
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::key_equal typename unordered_multimap<K,T,H,P,A>::key_equal
unordered_multimap<K,T,H,P,A>::key_eq() const unordered_multimap<K,T,H,P,A>::key_eq() const
{ {
return table_.key_eq(); return table_.key_eq();
@ -1457,14 +1449,14 @@ namespace unordered
// lookup // lookup
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::find(const key_type& k) unordered_multimap<K,T,H,P,A>::find(const key_type& k)
{ {
return iterator(table_.find_node(k)); return iterator(table_.find_node(k));
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::const_iterator typename unordered_multimap<K,T,H,P,A>::const_iterator
unordered_multimap<K,T,H,P,A>::find(const key_type& k) const unordered_multimap<K,T,H,P,A>::find(const key_type& k) const
{ {
return const_iterator(table_.find_node(k)); return const_iterator(table_.find_node(k));
@ -1473,7 +1465,7 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
template <class CompatibleKey, class CompatibleHash, template <class CompatibleKey, class CompatibleHash,
class CompatiblePredicate> class CompatiblePredicate>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator typename unordered_multimap<K,T,H,P,A>::iterator
unordered_multimap<K,T,H,P,A>::find( unordered_multimap<K,T,H,P,A>::find(
CompatibleKey const& k, CompatibleKey const& k,
CompatibleHash const& hash, CompatibleHash const& hash,
@ -1485,7 +1477,7 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
template <class CompatibleKey, class CompatibleHash, template <class CompatibleKey, class CompatibleHash,
class CompatiblePredicate> class CompatiblePredicate>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::const_iterator typename unordered_multimap<K,T,H,P,A>::const_iterator
unordered_multimap<K,T,H,P,A>::find( unordered_multimap<K,T,H,P,A>::find(
CompatibleKey const& k, CompatibleKey const& k,
CompatibleHash const& hash, CompatibleHash const& hash,
@ -1495,7 +1487,7 @@ namespace unordered
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::size_type typename unordered_multimap<K,T,H,P,A>::size_type
unordered_multimap<K,T,H,P,A>::count(const key_type& k) const unordered_multimap<K,T,H,P,A>::count(const key_type& k) const
{ {
return table_.count(k); return table_.count(k);
@ -1503,8 +1495,8 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
std::pair< std::pair<
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator, typename unordered_multimap<K,T,H,P,A>::iterator,
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::iterator> typename unordered_multimap<K,T,H,P,A>::iterator>
unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k) unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k)
{ {
return table_.equal_range(k); return table_.equal_range(k);
@ -1512,15 +1504,15 @@ namespace unordered
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
std::pair< std::pair<
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::const_iterator, typename unordered_multimap<K,T,H,P,A>::const_iterator,
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::const_iterator> typename unordered_multimap<K,T,H,P,A>::const_iterator>
unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k) const unordered_multimap<K,T,H,P,A>::equal_range(const key_type& k) const
{ {
return table_.equal_range(k); return table_.equal_range(k);
} }
template <class K, class T, class H, class P, class A> template <class K, class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multimap<K,T,H,P,A>::size_type typename unordered_multimap<K,T,H,P,A>::size_type
unordered_multimap<K,T,H,P,A>::bucket_size(size_type n) const unordered_multimap<K,T,H,P,A>::bucket_size(size_type n) const
{ {
return table_.bucket_size(n); return table_.bucket_size(n);

112
include/boost/unordered/unordered_set.hpp
View File

@ -52,8 +52,7 @@ namespace unordered
private: private:
#endif #endif
typedef BOOST_DEDUCED_TYPENAME typedef typename ::boost::unordered::detail::rebind_wrap<
::boost::unordered::detail::rebind_wrap<
allocator_type, value_type>::type allocator_type, value_type>::type
value_allocator; value_allocator;
typedef ::boost::unordered::detail::allocator_traits<value_allocator> typedef ::boost::unordered::detail::allocator_traits<value_allocator>
@ -61,16 +60,14 @@ namespace unordered
typedef ::boost::unordered::detail::set<H, P, typedef ::boost::unordered::detail::set<H, P,
value_allocator> types; value_allocator> types;
typedef BOOST_DEDUCED_TYPENAME types::impl table; typedef typename types::impl table;
typedef BOOST_DEDUCED_TYPENAME types::node_ptr node_ptr; typedef typename types::node_ptr node_ptr;
public: public:
typedef BOOST_DEDUCED_TYPENAME typedef typename allocator_traits::pointer pointer;
allocator_traits::pointer pointer; typedef typename allocator_traits::const_pointer const_pointer;
typedef BOOST_DEDUCED_TYPENAME
allocator_traits::const_pointer const_pointer;
typedef value_type& reference; typedef value_type& reference;
typedef value_type const& const_reference; typedef value_type const& const_reference;
@ -384,8 +381,7 @@ namespace unordered
private: private:
#endif #endif
typedef BOOST_DEDUCED_TYPENAME typedef typename ::boost::unordered::detail::rebind_wrap<
::boost::unordered::detail::rebind_wrap<
allocator_type, value_type>::type allocator_type, value_type>::type
value_allocator; value_allocator;
typedef ::boost::unordered::detail::allocator_traits<value_allocator> typedef ::boost::unordered::detail::allocator_traits<value_allocator>
@ -393,16 +389,14 @@ namespace unordered
typedef ::boost::unordered::detail::multiset<H, P, typedef ::boost::unordered::detail::multiset<H, P,
value_allocator> types; value_allocator> types;
typedef BOOST_DEDUCED_TYPENAME types::impl table; typedef typename types::impl table;
typedef BOOST_DEDUCED_TYPENAME types::node_ptr node_ptr; typedef typename types::node_ptr node_ptr;
public: public:
typedef BOOST_DEDUCED_TYPENAME typedef typename allocator_traits::pointer pointer;
allocator_traits::pointer pointer; typedef typename allocator_traits::const_pointer const_pointer;
typedef BOOST_DEDUCED_TYPENAME
allocator_traits::const_pointer const_pointer;
typedef value_type& reference; typedef value_type& reference;
typedef value_type const& const_reference; typedef value_type const& const_reference;
@ -818,7 +812,7 @@ namespace unordered
#if defined(BOOST_UNORDERED_STD_FORWARD_MOVE) #if defined(BOOST_UNORDERED_STD_FORWARD_MOVE)
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
template <class... Args> template <class... Args>
std::pair<BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator, bool> std::pair<typename unordered_set<T,H,P,A>::iterator, bool>
unordered_set<T,H,P,A>::emplace(Args&&... args) unordered_set<T,H,P,A>::emplace(Args&&... args)
{ {
return table_.emplace(std::forward<Args>(args)...); return table_.emplace(std::forward<Args>(args)...);
@ -826,7 +820,7 @@ namespace unordered
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
template <class... Args> template <class... Args>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator typename unordered_set<T,H,P,A>::iterator
unordered_set<T,H,P,A>::emplace_hint(const_iterator, Args&&... args) unordered_set<T,H,P,A>::emplace_hint(const_iterator, Args&&... args)
{ {
return iterator(table_.emplace(std::forward<Args>(args)...).first); return iterator(table_.emplace(std::forward<Args>(args)...).first);
@ -834,7 +828,7 @@ namespace unordered
#else #else
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
std::pair<BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator, bool> std::pair<typename unordered_set<T,H,P,A>::iterator, bool>
unordered_set<T,H,P,A>::emplace( unordered_set<T,H,P,A>::emplace(
boost::unordered::detail::empty_emplace, boost::unordered::detail::empty_emplace,
value_type v value_type v
@ -844,7 +838,7 @@ namespace unordered
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator typename unordered_set<T,H,P,A>::iterator
unordered_set<T,H,P,A>::emplace_hint(const_iterator, unordered_set<T,H,P,A>::emplace_hint(const_iterator,
boost::unordered::detail::empty_emplace, boost::unordered::detail::empty_emplace,
value_type v value_type v
@ -858,9 +852,7 @@ namespace unordered
template < \ template < \
BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
> \ > \
std::pair< \ std::pair<typename unordered_set<T,H,P,A>::iterator, bool> \
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator, \
bool> \
unordered_set<T,H,P,A>::emplace( \ unordered_set<T,H,P,A>::emplace( \
BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
{ \ { \
@ -871,7 +863,7 @@ namespace unordered
template < \ template < \
BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
> \ > \
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator \ typename unordered_set<T,H,P,A>::iterator \
unordered_set<T,H,P,A>::emplace_hint( \ unordered_set<T,H,P,A>::emplace_hint( \
const_iterator, \ const_iterator, \
BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, n) \
@ -889,14 +881,14 @@ namespace unordered
#endif #endif
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
std::pair<BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator, bool> std::pair<typename unordered_set<T,H,P,A>::iterator, bool>
unordered_set<T,H,P,A>::insert(value_type const& obj) unordered_set<T,H,P,A>::insert(value_type const& obj)
{ {
return table_.emplace(obj); return table_.emplace(obj);
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator typename unordered_set<T,H,P,A>::iterator
unordered_set<T,H,P,A>::insert(const_iterator, unordered_set<T,H,P,A>::insert(const_iterator,
value_type const& obj) value_type const& obj)
{ {
@ -905,14 +897,14 @@ namespace unordered
#if BOOST_UNORDERED_USE_RV_REF #if BOOST_UNORDERED_USE_RV_REF
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
std::pair<BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator, bool> std::pair<typename unordered_set<T,H,P,A>::iterator, bool>
unordered_set<T,H,P,A>::insert(BOOST_RV_REF(value_type) obj) unordered_set<T,H,P,A>::insert(BOOST_RV_REF(value_type) obj)
{ {
return table_.emplace(boost::move(obj)); return table_.emplace(boost::move(obj));
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator typename unordered_set<T,H,P,A>::iterator
unordered_set<T,H,P,A>::insert(const_iterator, unordered_set<T,H,P,A>::insert(const_iterator,
BOOST_RV_REF(value_type) obj) BOOST_RV_REF(value_type) obj)
{ {
@ -936,21 +928,21 @@ namespace unordered
#endif #endif
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator typename unordered_set<T,H,P,A>::iterator
unordered_set<T,H,P,A>::erase(const_iterator position) unordered_set<T,H,P,A>::erase(const_iterator position)
{ {
return iterator(table_.erase(position.node_)); return iterator(table_.erase(position.node_));
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::size_type typename unordered_set<T,H,P,A>::size_type
unordered_set<T,H,P,A>::erase(const key_type& k) unordered_set<T,H,P,A>::erase(const key_type& k)
{ {
return table_.erase_key(k); return table_.erase_key(k);
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::iterator typename unordered_set<T,H,P,A>::iterator
unordered_set<T,H,P,A>::erase(const_iterator first, const_iterator last) unordered_set<T,H,P,A>::erase(const_iterator first, const_iterator last)
{ {
return iterator(table_.erase_range(first.node_, last.node_)); return iterator(table_.erase_range(first.node_, last.node_));
@ -971,14 +963,14 @@ namespace unordered
// observers // observers
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::hasher typename unordered_set<T,H,P,A>::hasher
unordered_set<T,H,P,A>::hash_function() const unordered_set<T,H,P,A>::hash_function() const
{ {
return table_.hash_function(); return table_.hash_function();
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::key_equal typename unordered_set<T,H,P,A>::key_equal
unordered_set<T,H,P,A>::key_eq() const unordered_set<T,H,P,A>::key_eq() const
{ {
return table_.key_eq(); return table_.key_eq();
@ -987,7 +979,7 @@ namespace unordered
// lookup // lookup
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::const_iterator typename unordered_set<T,H,P,A>::const_iterator
unordered_set<T,H,P,A>::find(const key_type& k) const unordered_set<T,H,P,A>::find(const key_type& k) const
{ {
return const_iterator(table_.find_node(k)); return const_iterator(table_.find_node(k));
@ -996,7 +988,7 @@ namespace unordered
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
template <class CompatibleKey, class CompatibleHash, template <class CompatibleKey, class CompatibleHash,
class CompatiblePredicate> class CompatiblePredicate>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::const_iterator typename unordered_set<T,H,P,A>::const_iterator
unordered_set<T,H,P,A>::find( unordered_set<T,H,P,A>::find(
CompatibleKey const& k, CompatibleKey const& k,
CompatibleHash const& hash, CompatibleHash const& hash,
@ -1006,7 +998,7 @@ namespace unordered
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::size_type typename unordered_set<T,H,P,A>::size_type
unordered_set<T,H,P,A>::count(const key_type& k) const unordered_set<T,H,P,A>::count(const key_type& k) const
{ {
return table_.count(k); return table_.count(k);
@ -1014,15 +1006,15 @@ namespace unordered
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
std::pair< std::pair<
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::const_iterator, typename unordered_set<T,H,P,A>::const_iterator,
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::const_iterator> typename unordered_set<T,H,P,A>::const_iterator>
unordered_set<T,H,P,A>::equal_range(const key_type& k) const unordered_set<T,H,P,A>::equal_range(const key_type& k) const
{ {
return table_.equal_range(k); return table_.equal_range(k);
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_set<T,H,P,A>::size_type typename unordered_set<T,H,P,A>::size_type
unordered_set<T,H,P,A>::bucket_size(size_type n) const unordered_set<T,H,P,A>::bucket_size(size_type n) const
{ {
return table_.bucket_size(n); return table_.bucket_size(n);
@ -1198,7 +1190,7 @@ namespace unordered
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
template <class... Args> template <class... Args>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::emplace(Args&&... args) unordered_multiset<T,H,P,A>::emplace(Args&&... args)
{ {
return iterator(table_.emplace(std::forward<Args>(args)...)); return iterator(table_.emplace(std::forward<Args>(args)...));
@ -1206,7 +1198,7 @@ namespace unordered
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
template <class... Args> template <class... Args>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::emplace_hint( unordered_multiset<T,H,P,A>::emplace_hint(
const_iterator, Args&&... args) const_iterator, Args&&... args)
{ {
@ -1216,7 +1208,7 @@ namespace unordered
#else #else
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::emplace( unordered_multiset<T,H,P,A>::emplace(
boost::unordered::detail::empty_emplace, boost::unordered::detail::empty_emplace,
value_type v value_type v
@ -1226,7 +1218,7 @@ namespace unordered
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::emplace_hint(const_iterator, unordered_multiset<T,H,P,A>::emplace_hint(const_iterator,
boost::unordered::detail::empty_emplace, boost::unordered::detail::empty_emplace,
value_type v value_type v
@ -1240,7 +1232,7 @@ namespace unordered
template < \ template < \
BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
> \ > \
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator \ typename unordered_multiset<T,H,P,A>::iterator \
unordered_multiset<T,H,P,A>::emplace( \ unordered_multiset<T,H,P,A>::emplace( \
BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
{ \ { \
@ -1252,7 +1244,7 @@ namespace unordered
template < \ template < \
BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \ BOOST_UNORDERED_TEMPLATE_ARGS(z, n) \
> \ > \
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator \ typename unordered_multiset<T,H,P,A>::iterator \
unordered_multiset<T,H,P,A>::emplace_hint( \ unordered_multiset<T,H,P,A>::emplace_hint( \
const_iterator, \ const_iterator, \
BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \ BOOST_UNORDERED_FUNCTION_PARAMS(z, n)) \
@ -1269,14 +1261,14 @@ namespace unordered
#endif #endif
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::insert(value_type const& obj) unordered_multiset<T,H,P,A>::insert(value_type const& obj)
{ {
return iterator(table_.emplace(obj)); return iterator(table_.emplace(obj));
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::insert(const_iterator, unordered_multiset<T,H,P,A>::insert(const_iterator,
value_type const& obj) value_type const& obj)
{ {
@ -1285,14 +1277,14 @@ namespace unordered
#if BOOST_UNORDERED_USE_RV_REF #if BOOST_UNORDERED_USE_RV_REF
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::insert(BOOST_RV_REF(value_type) obj) unordered_multiset<T,H,P,A>::insert(BOOST_RV_REF(value_type) obj)
{ {
return iterator(table_.emplace(boost::move(obj))); return iterator(table_.emplace(boost::move(obj)));
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::insert(const_iterator, unordered_multiset<T,H,P,A>::insert(const_iterator,
BOOST_RV_REF(value_type) obj) BOOST_RV_REF(value_type) obj)
{ {
@ -1316,21 +1308,21 @@ namespace unordered
#endif #endif
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::erase(const_iterator position) unordered_multiset<T,H,P,A>::erase(const_iterator position)
{ {
return iterator(table_.erase(position.node_)); return iterator(table_.erase(position.node_));
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::size_type typename unordered_multiset<T,H,P,A>::size_type
unordered_multiset<T,H,P,A>::erase(const key_type& k) unordered_multiset<T,H,P,A>::erase(const key_type& k)
{ {
return table_.erase_key(k); return table_.erase_key(k);
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::iterator typename unordered_multiset<T,H,P,A>::iterator
unordered_multiset<T,H,P,A>::erase(const_iterator first, const_iterator last) unordered_multiset<T,H,P,A>::erase(const_iterator first, const_iterator last)
{ {
return iterator(table_.erase_range(first.node_, last.node_)); return iterator(table_.erase_range(first.node_, last.node_));
@ -1351,14 +1343,14 @@ namespace unordered
// observers // observers
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::hasher typename unordered_multiset<T,H,P,A>::hasher
unordered_multiset<T,H,P,A>::hash_function() const unordered_multiset<T,H,P,A>::hash_function() const
{ {
return table_.hash_function(); return table_.hash_function();
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::key_equal typename unordered_multiset<T,H,P,A>::key_equal
unordered_multiset<T,H,P,A>::key_eq() const unordered_multiset<T,H,P,A>::key_eq() const
{ {
return table_.key_eq(); return table_.key_eq();
@ -1367,7 +1359,7 @@ namespace unordered
// lookup // lookup
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::const_iterator typename unordered_multiset<T,H,P,A>::const_iterator
unordered_multiset<T,H,P,A>::find(const key_type& k) const unordered_multiset<T,H,P,A>::find(const key_type& k) const
{ {
return const_iterator(table_.find_node(k)); return const_iterator(table_.find_node(k));
@ -1376,7 +1368,7 @@ namespace unordered
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
template <class CompatibleKey, class CompatibleHash, template <class CompatibleKey, class CompatibleHash,
class CompatiblePredicate> class CompatiblePredicate>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::const_iterator typename unordered_multiset<T,H,P,A>::const_iterator
unordered_multiset<T,H,P,A>::find( unordered_multiset<T,H,P,A>::find(
CompatibleKey const& k, CompatibleKey const& k,
CompatibleHash const& hash, CompatibleHash const& hash,
@ -1386,7 +1378,7 @@ namespace unordered
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::size_type typename unordered_multiset<T,H,P,A>::size_type
unordered_multiset<T,H,P,A>::count(const key_type& k) const unordered_multiset<T,H,P,A>::count(const key_type& k) const
{ {
return table_.count(k); return table_.count(k);
@ -1394,15 +1386,15 @@ namespace unordered
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
std::pair< std::pair<
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::const_iterator, typename unordered_multiset<T,H,P,A>::const_iterator,
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::const_iterator> typename unordered_multiset<T,H,P,A>::const_iterator>
unordered_multiset<T,H,P,A>::equal_range(const key_type& k) const unordered_multiset<T,H,P,A>::equal_range(const key_type& k) const
{ {
return table_.equal_range(k); return table_.equal_range(k);
} }
template <class T, class H, class P, class A> template <class T, class H, class P, class A>
BOOST_DEDUCED_TYPENAME unordered_multiset<T,H,P,A>::size_type typename unordered_multiset<T,H,P,A>::size_type
unordered_multiset<T,H,P,A>::bucket_size(size_type n) const unordered_multiset<T,H,P,A>::bucket_size(size_type n) const
{ {
return table_.bucket_size(n); return table_.bucket_size(n);