forked from OSchip/llvm-project
Cleanup _LIBCPP_HAS_NO_<c++11-feature> in std::unordered_map and std::unordered_multimap
This completes the cleanup of the containers, at least within the tests. llvm-svn: 300620
This commit is contained in:
Eric Fiselier
parent
f0f86ef96f
commit
6a470bcb6d
|
|
@ -547,7 +547,7 @@ public:
|
|||
__second_constructed(false)
|
||||
{}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__hash_map_node_destructor(__hash_node_destructor<allocator_type>&& __x)
|
||||
_NOEXCEPT
|
||||
|
|
@ -557,7 +557,7 @@ public:
|
|||
{
|
||||
__x.__value_constructed = false;
|
||||
}
|
||||
#else // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#else // _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
__hash_map_node_destructor(const __hash_node_destructor<allocator_type>& __x)
|
||||
: __na_(__x.__na_),
|
||||
|
|
@ -566,7 +566,7 @@ public:
|
|||
{
|
||||
const_cast<bool&>(__x.__value_constructed) = false;
|
||||
}
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void operator()(pointer __p) _NOEXCEPT
|
||||
|
|
@ -819,20 +819,18 @@ public:
|
|||
explicit unordered_map(const allocator_type& __a);
|
||||
unordered_map(const unordered_map& __u);
|
||||
unordered_map(const unordered_map& __u, const allocator_type& __a);
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unordered_map(unordered_map&& __u)
|
||||
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
|
||||
unordered_map(unordered_map&& __u, const allocator_type& __a);
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
unordered_map(initializer_list<value_type> __il);
|
||||
unordered_map(initializer_list<value_type> __il, size_type __n,
|
||||
const hasher& __hf = hasher(), const key_equal& __eql = key_equal());
|
||||
unordered_map(initializer_list<value_type> __il, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unordered_map(size_type __n, const allocator_type& __a)
|
||||
|
|
@ -875,15 +873,13 @@ public:
|
|||
#endif
|
||||
return *this;
|
||||
}
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unordered_map& operator=(unordered_map&& __u)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
|
||||
#endif
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unordered_map& operator=(initializer_list<value_type> __il);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
allocator_type get_allocator() const _NOEXCEPT
|
||||
|
|
@ -928,13 +924,11 @@ public:
|
|||
_LIBCPP_INLINE_VISIBILITY
|
||||
void insert(_InputIterator __first, _InputIterator __last);
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void insert(initializer_list<value_type> __il)
|
||||
{insert(__il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
pair<iterator, bool> insert(value_type&& __x)
|
||||
{return __table_.__insert_unique(_VSTD::move(__x));}
|
||||
|
|
@ -1078,7 +1072,7 @@ public:
|
|||
// FIXME: Add debug mode checking for the iterator input
|
||||
return insert_or_assign(_VSTD::move(__k), _VSTD::forward<_Vp>(__v)).first;
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_STD_VER > 14
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator erase(const_iterator __p) {return __table_.erase(__p.__i_);}
|
||||
|
|
@ -1277,7 +1271,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|||
insert(__u.begin(), __u.end());
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
inline
|
||||
|
|
@ -1314,10 +1308,6 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|||
#endif
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
||||
initializer_list<value_type> __il)
|
||||
|
|
@ -1354,10 +1344,6 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
|
|||
insert(__il.begin(), __il.end());
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
inline
|
||||
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
|
||||
|
|
@ -1368,10 +1354,6 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
|
|||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
inline
|
||||
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
|
||||
|
|
@ -1382,22 +1364,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
|
|||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifdef _LIBCPP_CXX03_LANG
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
|
||||
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k)
|
||||
{
|
||||
__node_allocator& __na = __table_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first), __k);
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
|
||||
__h.get_deleter().__second_constructed = true;
|
||||
return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
template <class _InputIterator>
|
||||
|
|
@ -1410,20 +1377,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterator __first,
|
|||
__table_.__insert_unique(*__first);
|
||||
}
|
||||
|
||||
#ifdef _LIBCPP_CXX03_LANG
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
_Tp&
|
||||
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
|
||||
{
|
||||
iterator __i = find(__k);
|
||||
if (__i != end())
|
||||
return __i->second;
|
||||
__node_holder __h = __construct_node_with_key(__k);
|
||||
pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
|
||||
__h.release();
|
||||
return __r.first->second;
|
||||
}
|
||||
#else
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
_Tp&
|
||||
|
|
@ -1442,8 +1396,35 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k)
|
|||
std::piecewise_construct, std::forward_as_tuple(std::move(__k)),
|
||||
std::forward_as_tuple()).first->__cc.second;
|
||||
}
|
||||
#else // _LIBCPP_CXX03_LANG
|
||||
|
||||
#endif // !_LIBCPP_CXX03_MODE
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
|
||||
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node_with_key(const key_type& __k)
|
||||
{
|
||||
__node_allocator& __na = __table_.__node_alloc();
|
||||
__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.first), __k);
|
||||
__h.get_deleter().__first_constructed = true;
|
||||
__node_traits::construct(__na, _VSTD::addressof(__h->__value_.__cc.second));
|
||||
__h.get_deleter().__second_constructed = true;
|
||||
return _LIBCPP_EXPLICIT_MOVE(__h); // explicitly moved for C++03
|
||||
}
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
_Tp&
|
||||
unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k)
|
||||
{
|
||||
iterator __i = find(__k);
|
||||
if (__i != end())
|
||||
return __i->second;
|
||||
__node_holder __h = __construct_node_with_key(__k);
|
||||
pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
|
||||
__h.release();
|
||||
return __r.first->second;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_CXX03_MODE
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
_Tp&
|
||||
|
|
@ -1586,13 +1567,11 @@ public:
|
|||
explicit unordered_multimap(const allocator_type& __a);
|
||||
unordered_multimap(const unordered_multimap& __u);
|
||||
unordered_multimap(const unordered_multimap& __u, const allocator_type& __a);
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unordered_multimap(unordered_multimap&& __u)
|
||||
_NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
|
||||
unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
unordered_multimap(initializer_list<value_type> __il);
|
||||
unordered_multimap(initializer_list<value_type> __il, size_type __n,
|
||||
const hasher& __hf = hasher(),
|
||||
|
|
@ -1600,7 +1579,7 @@ public:
|
|||
unordered_multimap(initializer_list<value_type> __il, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
#if _LIBCPP_STD_VER > 11
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unordered_multimap(size_type __n, const allocator_type& __a)
|
||||
|
|
@ -1643,15 +1622,13 @@ public:
|
|||
#endif
|
||||
return *this;
|
||||
}
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unordered_multimap& operator=(unordered_multimap&& __u)
|
||||
_NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
|
||||
#endif
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
unordered_multimap& operator=(initializer_list<value_type> __il);
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
allocator_type get_allocator() const _NOEXCEPT
|
||||
|
|
@ -1688,13 +1665,10 @@ public:
|
|||
_LIBCPP_INLINE_VISIBILITY
|
||||
void insert(_InputIterator __first, _InputIterator __last);
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
void insert(initializer_list<value_type> __il)
|
||||
{insert(__il.begin(), __il.end());}
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
_LIBCPP_INLINE_VISIBILITY
|
||||
iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));}
|
||||
|
||||
|
|
@ -1912,7 +1886,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|||
insert(__u.begin(), __u.end());
|
||||
}
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#ifndef _LIBCPP_CXX03_LANG
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
inline
|
||||
|
|
@ -1951,10 +1925,6 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|||
#endif
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
||||
initializer_list<value_type> __il)
|
||||
|
|
@ -1991,10 +1961,6 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
|
|||
insert(__il.begin(), __il.end());
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
inline
|
||||
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
|
||||
|
|
@ -2005,10 +1971,6 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multima
|
|||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
|
||||
template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
|
||||
inline
|
||||
unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
|
||||
|
|
@ -2019,7 +1981,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
|
|||
return *this;
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // _LIBCPP_CXX03_LANG
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -10,7 +10,10 @@
|
|||
#ifndef EMPLACEABLE_H
|
||||
#define EMPLACEABLE_H
|
||||
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
#include <utility>
|
||||
#include "test_macros.h"
|
||||
|
||||
#if TEST_STD_VER >= 11
|
||||
|
||||
class Emplaceable
|
||||
{
|
||||
|
|
@ -49,6 +52,5 @@ struct hash<Emplaceable>
|
|||
|
||||
}
|
||||
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
|
||||
#endif // TEST_STD_VER >= 11
|
||||
#endif // EMPLACEABLE_H
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -27,7 +29,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::allocator<std::pair<const int, std::string> > A;
|
||||
typedef std::unordered_map<int, std::string,
|
||||
|
|
@ -60,7 +61,6 @@ int main()
|
|||
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef min_allocator<std::pair<const int, std::string> > A;
|
||||
typedef std::unordered_map<int, std::string,
|
||||
|
|
@ -93,6 +93,4 @@ int main()
|
|||
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -29,7 +31,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
{
|
||||
typedef test_allocator<std::pair<const int, std::string> > A;
|
||||
typedef std::unordered_map<int, std::string,
|
||||
|
|
@ -167,7 +168,6 @@ int main()
|
|||
assert(c.max_load_factor() == 1);
|
||||
assert(c0.size() == 0);
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef min_allocator<std::pair<const int, std::string> > A;
|
||||
typedef std::unordered_map<int, std::string,
|
||||
|
|
@ -214,18 +214,4 @@ int main()
|
|||
assert(c.max_load_factor() == 1);
|
||||
assert(c0.size() == 0);
|
||||
}
|
||||
#endif
|
||||
#if _LIBCPP_DEBUG >= 1
|
||||
{
|
||||
std::unordered_map<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};
|
||||
std::unordered_map<int, int>::iterator i = s1.begin();
|
||||
std::pair<const int, int> k = *i;
|
||||
std::unordered_map<int, int> s2;
|
||||
s2 = std::move(s1);
|
||||
assert(*i == k);
|
||||
s2.erase(i);
|
||||
assert(s2.size() == 2);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -29,7 +31,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -61,7 +62,6 @@ int main()
|
|||
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -158,7 +158,5 @@ int main()
|
|||
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // TEST_STD_VER > 11
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -30,7 +32,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -64,7 +65,6 @@ int main()
|
|||
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -98,6 +98,4 @@ int main()
|
|||
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -30,7 +32,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -65,7 +66,6 @@ int main()
|
|||
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -100,6 +100,4 @@ int main()
|
|||
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -31,7 +33,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -67,7 +68,6 @@ int main()
|
|||
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -103,6 +103,4 @@ int main()
|
|||
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -31,7 +33,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -68,7 +69,6 @@ int main()
|
|||
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_map<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -141,6 +141,4 @@ int main()
|
|||
assert(std::fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -30,7 +32,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
{
|
||||
typedef std::pair<int, std::string> P;
|
||||
typedef test_allocator<std::pair<const int, std::string>> A;
|
||||
|
|
@ -113,7 +114,6 @@ int main()
|
|||
|
||||
assert(c0.empty());
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::pair<int, std::string> P;
|
||||
typedef min_allocator<std::pair<const int, std::string>> A;
|
||||
|
|
@ -196,6 +196,4 @@ int main()
|
|||
|
||||
assert(c0.empty());
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -24,7 +26,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
{
|
||||
typedef std::unordered_map<int, Emplaceable> C;
|
||||
typedef std::pair<C::iterator, bool> R;
|
||||
|
|
@ -49,7 +50,6 @@ int main()
|
|||
assert(r.first->first == 5);
|
||||
assert(r.first->second == Emplaceable(6, 7));
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_map<int, Emplaceable, std::hash<int>, std::equal_to<int>,
|
||||
min_allocator<std::pair<const int, Emplaceable>>> C;
|
||||
|
|
@ -75,6 +75,4 @@ int main()
|
|||
assert(r.first->first == 5);
|
||||
assert(r.first->second == Emplaceable(6, 7));
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -16,9 +18,6 @@
|
|||
// template <class... Args>
|
||||
// iterator emplace_hint(const_iterator p, Args&&... args);
|
||||
|
||||
#if _LIBCPP_DEBUG >= 1
|
||||
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
|
||||
#endif
|
||||
|
||||
#include <unordered_map>
|
||||
#include <cassert>
|
||||
|
|
@ -28,7 +27,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
{
|
||||
typedef std::unordered_map<int, Emplaceable> C;
|
||||
typedef C::iterator R;
|
||||
|
|
@ -51,7 +49,6 @@ int main()
|
|||
assert(r->first == 5);
|
||||
assert(r->second == Emplaceable(6, 7));
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_map<int, Emplaceable, std::hash<int>, std::equal_to<int>,
|
||||
min_allocator<std::pair<const int, Emplaceable>>> C;
|
||||
|
|
@ -75,19 +72,4 @@ int main()
|
|||
assert(r->first == 5);
|
||||
assert(r->second == Emplaceable(6, 7));
|
||||
}
|
||||
#endif
|
||||
#if _LIBCPP_DEBUG >= 1
|
||||
{
|
||||
typedef std::unordered_map<int, Emplaceable> C;
|
||||
typedef C::iterator R;
|
||||
typedef C::value_type P;
|
||||
C c;
|
||||
C c2;
|
||||
R r = c.emplace_hint(c2.end(), std::piecewise_construct,
|
||||
std::forward_as_tuple(3),
|
||||
std::forward_as_tuple());
|
||||
assert(false);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -24,7 +26,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_map<int, std::string> C;
|
||||
typedef std::pair<int, std::string> P;
|
||||
|
|
@ -45,7 +46,6 @@ int main()
|
|||
assert(c.at(3) == "three");
|
||||
assert(c.at(4) == "four");
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_map<int, std::string, std::hash<int>, std::equal_to<int>,
|
||||
min_allocator<std::pair<const int, std::string>>> C;
|
||||
|
|
@ -67,6 +67,4 @@ int main()
|
|||
assert(c.at(3) == "three");
|
||||
assert(c.at(4) == "four");
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -28,7 +30,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef test_allocator<std::pair<const int, std::string> > A;
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
|
|
@ -85,7 +86,6 @@ int main()
|
|||
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef min_allocator<std::pair<const int, std::string> > A;
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
|
|
@ -142,6 +142,4 @@ int main()
|
|||
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -29,7 +31,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
{
|
||||
typedef test_allocator<std::pair<const int, std::string> > A;
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
|
|
@ -225,7 +226,6 @@ int main()
|
|||
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef min_allocator<std::pair<const int, std::string> > A;
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
|
|
@ -291,18 +291,4 @@ int main()
|
|||
assert(fabs(c.load_factor() - (float)c.size()/c.bucket_count()) < FLT_EPSILON);
|
||||
assert(c.max_load_factor() == 1);
|
||||
}
|
||||
#endif
|
||||
#if _LIBCPP_DEBUG >= 1
|
||||
{
|
||||
std::unordered_multimap<int, int> s1 = {{1, 1}, {2, 2}, {3, 3}};
|
||||
std::unordered_multimap<int, int>::iterator i = s1.begin();
|
||||
std::pair<const int, int> k = *i;
|
||||
std::unordered_multimap<int, int> s2;
|
||||
s2 = std::move(s1);
|
||||
assert(*i == k);
|
||||
s2.erase(i);
|
||||
assert(s2.size() == 2);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -29,7 +31,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -83,7 +84,6 @@ int main()
|
|||
assert(c.key_eq() == test_compare<std::equal_to<int> >());
|
||||
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -250,7 +250,5 @@ int main()
|
|||
assert(c.get_allocator() == a);
|
||||
assert(!(c.get_allocator() == A()));
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
#endif // TEST_STD_VER > 11
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -30,7 +32,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -86,7 +87,6 @@ int main()
|
|||
assert(c.key_eq() == test_compare<std::equal_to<int> >());
|
||||
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -142,6 +142,4 @@ int main()
|
|||
assert(c.key_eq() == test_compare<std::equal_to<int> >());
|
||||
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -30,7 +32,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -87,7 +88,6 @@ int main()
|
|||
assert(c.key_eq() == test_compare<std::equal_to<int> >());
|
||||
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -144,6 +144,4 @@ int main()
|
|||
assert(c.key_eq() == test_compare<std::equal_to<int> >());
|
||||
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -31,7 +33,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -89,7 +90,6 @@ int main()
|
|||
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
|
||||
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >()));
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -147,6 +147,4 @@ int main()
|
|||
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
|
||||
assert((c.get_allocator() == min_allocator<std::pair<const int, std::string> >()));
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -31,7 +33,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -90,7 +91,6 @@ int main()
|
|||
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
|
||||
assert((c.get_allocator() == test_allocator<std::pair<const int, std::string> >(10)));
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string,
|
||||
test_hash<std::hash<int> >,
|
||||
|
|
@ -208,6 +208,4 @@ int main()
|
|||
assert(c.key_eq() == test_compare<std::equal_to<int> >(9));
|
||||
assert(c.get_allocator() == A{});
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -32,7 +34,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
{
|
||||
typedef std::pair<int, std::string> P;
|
||||
typedef test_allocator<std::pair<const int, std::string>> A;
|
||||
|
|
@ -161,7 +162,6 @@ int main()
|
|||
|
||||
assert(c0.empty());
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::pair<int, std::string> P;
|
||||
typedef min_allocator<std::pair<const int, std::string>> A;
|
||||
|
|
@ -290,6 +290,4 @@ int main()
|
|||
|
||||
assert(c0.empty());
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -24,7 +26,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
{
|
||||
typedef std::unordered_multimap<int, Emplaceable> C;
|
||||
typedef C::iterator R;
|
||||
|
|
@ -46,7 +47,6 @@ int main()
|
|||
assert(r->first == 5);
|
||||
assert(r->second == Emplaceable(6, 7));
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_multimap<int, Emplaceable, std::hash<int>, std::equal_to<int>,
|
||||
min_allocator<std::pair<const int, Emplaceable>>> C;
|
||||
|
|
@ -69,6 +69,4 @@ int main()
|
|||
assert(r->first == 5);
|
||||
assert(r->second == Emplaceable(6, 7));
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -16,9 +18,6 @@
|
|||
// template <class... Args>
|
||||
// iterator emplace_hint(const_iterator p, Args&&... args);
|
||||
|
||||
#if _LIBCPP_DEBUG >= 1
|
||||
#define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : std::exit(0))
|
||||
#endif
|
||||
|
||||
#include <unordered_map>
|
||||
#include <cassert>
|
||||
|
|
@ -29,7 +28,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
{
|
||||
typedef std::unordered_multimap<int, Emplaceable> C;
|
||||
typedef C::iterator R;
|
||||
|
|
@ -60,7 +58,6 @@ int main()
|
|||
assert(r->first == 3);
|
||||
LIBCPP_ASSERT(r->second == Emplaceable(5, 6));
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_multimap<int, Emplaceable, std::hash<int>, std::equal_to<int>,
|
||||
min_allocator<std::pair<const int, Emplaceable>>> C;
|
||||
|
|
@ -92,19 +89,4 @@ int main()
|
|||
assert(r->first == 3);
|
||||
LIBCPP_ASSERT(r->second == Emplaceable(5, 6));
|
||||
}
|
||||
#endif
|
||||
#if _LIBCPP_DEBUG >= 1
|
||||
{
|
||||
typedef std::unordered_multimap<int, Emplaceable> C;
|
||||
typedef C::iterator R;
|
||||
typedef C::value_type P;
|
||||
C c;
|
||||
C c2;
|
||||
R r = c.emplace_hint(c2.end(), std::piecewise_construct,
|
||||
std::forward_as_tuple(3),
|
||||
std::forward_as_tuple());
|
||||
assert(false);
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,6 +7,8 @@
|
|||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// UNSUPPORTED: c++98, c++03
|
||||
|
||||
// <unordered_map>
|
||||
|
||||
// template <class Key, class T, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||||
|
|
@ -25,7 +27,6 @@
|
|||
|
||||
int main()
|
||||
{
|
||||
#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string> C;
|
||||
typedef std::pair<int, std::string> P;
|
||||
|
|
@ -71,7 +72,6 @@ int main()
|
|||
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
|
||||
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
|
||||
}
|
||||
#if TEST_STD_VER >= 11
|
||||
{
|
||||
typedef std::unordered_multimap<int, std::string, std::hash<int>, std::equal_to<int>,
|
||||
min_allocator<std::pair<const int, std::string>>> C;
|
||||
|
|
@ -118,6 +118,4 @@ int main()
|
|||
assert(static_cast<std::size_t>(std::distance(c.begin(), c.end())) == c.size());
|
||||
assert(static_cast<std::size_t>(std::distance(c.cbegin(), c.cend())) == c.size());
|
||||
}
|
||||
#endif
|
||||
#endif // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue