git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

alloc_traits.h (__allow_copy_cons): Remove. 

* include/bits/alloc_traits.h (__allow_copy_cons): Remove.
	(__check_copy_constructible): Likewise.
	* include/bits/unordered_map.h (unordered_map, unordered_multimap):
	Do not derive from __check_copy_constructible.
	* include/bits/unordered_set.h (unordered_set, unordered_multiset):
	Likewise.
	* testsuite/23_containers/unordered_map/55043.cc: It is no longer
	necessary for is_copy_constructible to be correct to use nested
	unordered containers.
	* testsuite/23_containers/unordered_multimap/55043.cc: Likewise.
	* testsuite/23_containers/unordered_set/55043.cc: Likewise.
	* testsuite/23_containers/unordered_multiset/55043.cc: Likewise.

From-SVN: r204790
This commit is contained in:
Jonathan Wakely 2013-11-14 12:43:00 +00:00 committed by Jonathan Wakely
parent e4603a754f
commit 8ed13e2757
8 changed files with 19 additions and 125 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,18 @@
2013-11-14 Jonathan Wakely <jwakely.gcc@gmail.com>
* include/bits/alloc_traits.h (__allow_copy_cons): Remove.
(__check_copy_constructible): Likewise.
* include/bits/unordered_map.h (unordered_map, unordered_multimap):
Do not derive from __check_copy_constructible.
* include/bits/unordered_set.h (unordered_set, unordered_multiset):
Likewise.
* testsuite/23_containers/unordered_map/55043.cc: It is no longer
necessary for is_copy_constructible to be correct to use nested
unordered containers.
* testsuite/23_containers/unordered_multimap/55043.cc: Likewise.
* testsuite/23_containers/unordered_set/55043.cc: Likewise.
* testsuite/23_containers/unordered_multiset/55043.cc: Likewise.
2013-11-13 Marc Glisse <marc.glisse@inria.fr>
PR libstdc++/59087

18
libstdc++-v3/include/bits/alloc_traits.h
View File

@ -541,24 +541,6 @@ _GLIBCXX_ALLOC_TR_NESTED_TYPE(propagate_on_container_swap,
: is_copy_constructible<_Tp>
{ };
// Used to allow copy construction of unordered containers
template<bool> struct __allow_copy_cons { };
// Used to delete copy constructor of unordered containers
template<>
struct __allow_copy_cons<false>
{
__allow_copy_cons() = default;
__allow_copy_cons(const __allow_copy_cons&) = delete;
__allow_copy_cons(__allow_copy_cons&&) = default;
__allow_copy_cons& operator=(const __allow_copy_cons&) = default;
__allow_copy_cons& operator=(__allow_copy_cons&&) = default;
};
template<typename _Alloc>
using __check_copy_constructible
= __allow_copy_cons<__is_copy_insertable<_Alloc>::value>;
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

4
libstdc++-v3/include/bits/unordered_map.h
View File

@ -95,7 +95,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
class _Hash = hash<_Key>,
class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
class unordered_map : __check_copy_constructible<_Alloc>
class unordered_map
{
typedef __umap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
_Hashtable _M_h;
@ -807,7 +807,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
class _Hash = hash<_Key>,
class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
class unordered_multimap : __check_copy_constructible<_Alloc>
class unordered_multimap
{
typedef __ummap_hashtable<_Key, _Tp, _Hash, _Pred, _Alloc> _Hashtable;
_Hashtable _M_h;

4
libstdc++-v3/include/bits/unordered_set.h
View File

@ -90,7 +90,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
class _Hash = hash<_Value>,
class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value> >
class unordered_set : __check_copy_constructible<_Alloc>
class unordered_set
{
typedef __uset_hashtable<_Value, _Hash, _Pred, _Alloc> _Hashtable;
_Hashtable _M_h;
@ -725,7 +725,7 @@ _GLIBCXX_BEGIN_NAMESPACE_CONTAINER
class _Hash = hash<_Value>,
class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value> >
class unordered_multiset : __check_copy_constructible<_Alloc>
class unordered_multiset
{
typedef __umset_hashtable<_Value, _Hash, _Pred, _Alloc> _Hashtable;
_Hashtable _M_h;

25
libstdc++-v3/testsuite/23_containers/unordered_map/55043.cc
View File

@ -42,28 +42,3 @@ void test01()
v.emplace_back(uim());
}
// Unordered containers don't use allocator_traits yet so need full
// Allocator interface, derive from std::allocator to get it.
template<typename T, bool R>
struct Alloc : std::allocator<T>
{
template<typename U>
struct rebind { typedef Alloc<U, R> other; };
Alloc() = default;
template<typename U>
Alloc(const Alloc<U, R>&) { }
typedef typename std::conditional<R, T&&, const T&>::type arg_type;
void construct(T* p, arg_type) const
{ new((void*)p) T(); }
};
// verify is_copy_constructible depends on allocator
typedef test_type<Alloc<MoveOnly, true>> uim_rval;
static_assert(!std::is_copy_constructible<uim_rval>::value, "is not copyable");
typedef test_type<Alloc<MoveOnly, false>> uim_lval;
static_assert(std::is_copy_constructible<uim_lval>::value, "is copyable");

26
libstdc++-v3/testsuite/23_containers/unordered_multimap/55043.cc
View File

@ -41,29 +41,3 @@ void test01()
std::vector<uim> v;
v.emplace_back(uim());
}
// Unordered containers don't use allocator_traits yet so need full
// Allocator interface, derive from std::allocator to get it.
template<typename T, bool R>
struct Alloc : std::allocator<T>
{
template<typename U>
struct rebind { typedef Alloc<U, R> other; };
Alloc() = default;
template<typename U>
Alloc(const Alloc<U, R>&) { }
typedef typename std::conditional<R, T&&, const T&>::type arg_type;
void construct(T* p, arg_type) const
{ new((void*)p) T(); }
};
// verify is_copy_constructible depends on allocator
typedef test_type<Alloc<MoveOnly, true>> uim_rval;
static_assert(!std::is_copy_constructible<uim_rval>::value, "is not copyable");
typedef test_type<Alloc<MoveOnly, false>> uim_lval;
static_assert(std::is_copy_constructible<uim_lval>::value, "is copyable");

26
libstdc++-v3/testsuite/23_containers/unordered_multiset/55043.cc
View File

@ -45,29 +45,3 @@ void test01()
std::vector<uim> v;
v.emplace_back(uim());
}
// Unordered containers don't use allocator_traits yet so need full
// Allocator interface, derive from std::allocator to get it.
template<typename T, bool R>
struct Alloc : std::allocator<T>
{
template<typename U>
struct rebind { typedef Alloc<U, R> other; };
Alloc() = default;
template<typename U>
Alloc(const Alloc<U, R>&) { }
typedef typename std::conditional<R, T&&, const T&>::type arg_type;
void construct(T* p, arg_type) const
{ new((void*)p) T(); }
};
// verify is_copy_constructible depends on allocator
typedef test_type<Alloc<MoveOnly, true>> uim_rval;
static_assert(!std::is_copy_constructible<uim_rval>::value, "is not copyable");
typedef test_type<Alloc<MoveOnly, false>> uim_lval;
static_assert(std::is_copy_constructible<uim_lval>::value, "is copyable");

26
libstdc++-v3/testsuite/23_containers/unordered_set/55043.cc
View File

@ -45,29 +45,3 @@ void test01()
std::vector<uim> v;
v.emplace_back(uim());
}
// Unordered containers don't use allocator_traits yet so need full
// Allocator interface, derive from std::allocator to get it.
template<typename T, bool R>
struct Alloc : std::allocator<T>
{
template<typename U>
struct rebind { typedef Alloc<U, R> other; };
Alloc() = default;
template<typename U>
Alloc(const Alloc<U, R>&) { }
typedef typename std::conditional<R, T&&, const T&>::type arg_type;
void construct(T* p, arg_type) const
{ new((void*)p) T(); }
};
// verify is_copy_constructible depends on allocator
typedef test_type<Alloc<MoveOnly, true>> uim_rval;
static_assert(!std::is_copy_constructible<uim_rval>::value, "is not copyable");
typedef test_type<Alloc<MoveOnly, false>> uim_lval;
static_assert(std::is_copy_constructible<uim_lval>::value, "is copyable");