generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

SCARY/N2913 iterator support between the multi and non-multi versions of the associative and unordered containers. I beleive lack of support for this was accidentally recently introduced (by me) and this is fixing a regression. This time tests are put in to prevent such a regression in the future.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@191692 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Howard Hinnant 2013-09-30 19:08:22 +00:00
parent 179fa78da3
commit ff7546e974
6 changed files with 234 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
include/map
View File

@ -575,6 +575,75 @@ template <class _Key, class _Tp, class _Compare, class _Allocator>
class multimap; class multimap;
template <class _TreeIterator> class __map_const_iterator; template <class _TreeIterator> class __map_const_iterator;
#if __cplusplus >= 201103L
template <class _Key, class _Tp>
union __value_type
{
typedef _Key key_type;
typedef _Tp mapped_type;
typedef pair<const key_type, mapped_type> value_type;
typedef pair<key_type, mapped_type> __nc_value_type;
value_type __cc;
__nc_value_type __nc;
template <class ..._Args>
_LIBCPP_INLINE_VISIBILITY
__value_type(_Args&& ...__args)
: __cc(std::forward<_Args>(__args)...) {}
_LIBCPP_INLINE_VISIBILITY
__value_type(const __value_type& __v)
: __cc(__v.__cc) {}
_LIBCPP_INLINE_VISIBILITY
__value_type(__value_type& __v)
: __cc(__v.__cc) {}
_LIBCPP_INLINE_VISIBILITY
__value_type(__value_type&& __v)
: __nc(std::move(__v.__nc)) {}
_LIBCPP_INLINE_VISIBILITY
__value_type& operator=(const __value_type& __v)
{__nc = __v.__cc; return *this;}
_LIBCPP_INLINE_VISIBILITY
__value_type& operator=(__value_type&& __v)
{__nc = std::move(__v.__nc); return *this;}
_LIBCPP_INLINE_VISIBILITY
~__value_type() {__cc.~value_type();}
};
#else
template <class _Key, class _Tp>
struct __value_type
{
typedef _Key key_type;
typedef _Tp mapped_type;
typedef pair<const key_type, mapped_type> value_type;
value_type __cc;
_LIBCPP_INLINE_VISIBILITY
__value_type() {}
template <class _A0>
_LIBCPP_INLINE_VISIBILITY
__value_type(const _A0& __a0)
: __cc(__a0) {}
template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY
__value_type(const _A0& __a0, const _A1& __a1)
: __cc(__a0, __a1) {}
};
#endif
template <class _TreeIterator> template <class _TreeIterator>
class _LIBCPP_TYPE_VIS_ONLY __map_iterator class _LIBCPP_TYPE_VIS_ONLY __map_iterator
{ {
@ -740,49 +809,7 @@ public:
private: private:
#if __cplusplus >= 201103L typedef _VSTD::__value_type<key_type, mapped_type> __value_type;
union __value_type
{
typedef typename map::value_type value_type;
typedef typename map::__nc_value_type __nc_value_type;
value_type __cc;
__nc_value_type __nc;
template <class ..._Args>
__value_type(_Args&& ...__args)
: __cc(std::forward<_Args>(__args)...) {}
__value_type(const __value_type& __v)
: __cc(__v.__cc) {}
__value_type(__value_type&& __v)
: __nc(std::move(__v.__nc)) {}
__value_type& operator=(const __value_type& __v)
{__nc = __v.__cc; return *this;}
__value_type& operator=(__value_type&& __v)
{__nc = std::move(__v.__nc); return *this;}
~__value_type() {__cc.~value_type();}
};
#else
struct __value_type
{
typedef typename map::value_type value_type;
value_type __cc;
__value_type() {}
template <class _A0>
__value_type(const _A0& __a0)
: __cc(__a0) {}
template <class _A0, class _A1>
__value_type(const _A0& __a0, const _A1& __a1)
: __cc(__a0, __a1) {}
};
#endif
typedef __map_value_compare<key_type, __value_type, key_compare> __vc; typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
typedef typename allocator_traits<allocator_type>::template typedef typename allocator_traits<allocator_type>::template
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
@ -1512,49 +1539,8 @@ public:
}; };
private: private:
#if __cplusplus >= 201103L
union __value_type
{
typedef typename multimap::value_type value_type;
typedef typename multimap::__nc_value_type __nc_value_type;
value_type __cc;
__nc_value_type __nc;
template <class ..._Args> typedef _VSTD::__value_type<key_type, mapped_type> __value_type;
__value_type(_Args&& ...__args)
: __cc(std::forward<_Args>(__args)...) {}
__value_type(const __value_type& __v)
: __cc(std::move(__v.__cc)) {}
__value_type(__value_type&& __v)
: __nc(std::move(__v.__nc)) {}
__value_type& operator=(const __value_type& __v)
{__nc = __v.__cc; return *this;}
__value_type& operator=(__value_type&& __v)
{__nc = std::move(__v.__nc); return *this;}
~__value_type() {__cc.~value_type();}
};
#else
struct __value_type
{
typedef typename multimap::value_type value_type;
value_type __cc;
__value_type() {}
template <class _A0>
__value_type(const _A0& __a0)
: __cc(__a0) {}
template <class _A0, class _A1>
__value_type(const _A0& __a0, const _A1& __a1)
: __cc(__a0, __a1) {}
};
#endif
typedef __map_value_compare<key_type, __value_type, key_compare> __vc; typedef __map_value_compare<key_type, __value_type, key_compare> __vc;
typedef typename allocator_traits<allocator_type>::template typedef typename allocator_traits<allocator_type>::template
#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES

153
include/unordered_map
View File

@ -525,6 +525,71 @@ public:
} }
}; };
#if __cplusplus >= 201103L
template <class _Key, class _Tp>
union __hash_value_type
{
typedef _Key key_type;
typedef _Tp mapped_type;
typedef pair<const key_type, mapped_type> value_type;
typedef pair<key_type, mapped_type> __nc_value_type;
value_type __cc;
__nc_value_type __nc;
template <class ..._Args>
_LIBCPP_INLINE_VISIBILITY
__hash_value_type(_Args&& ...__args)
: __cc(std::forward<_Args>(__args)...) {}
_LIBCPP_INLINE_VISIBILITY
__hash_value_type(const __hash_value_type& __v)
: __cc(__v.__cc) {}
_LIBCPP_INLINE_VISIBILITY
__hash_value_type(__hash_value_type&& __v)
: __nc(std::move(__v.__nc)) {}
_LIBCPP_INLINE_VISIBILITY
__hash_value_type& operator=(const __hash_value_type& __v)
{__nc = __v.__cc; return *this;}
_LIBCPP_INLINE_VISIBILITY
__hash_value_type& operator=(__hash_value_type&& __v)
{__nc = std::move(__v.__nc); return *this;}
_LIBCPP_INLINE_VISIBILITY
~__hash_value_type() {__cc.~value_type();}
};
#else
template <class _Key, class _Tp>
struct __hash_value_type
{
typedef _Key key_type;
typedef _Tp mapped_type;
typedef pair<const key_type, mapped_type> value_type;
value_type __cc;
_LIBCPP_INLINE_VISIBILITY
__hash_value_type() {}
template <class _A0>
_LIBCPP_INLINE_VISIBILITY
__hash_value_type(const _A0& __a0)
: __cc(__a0) {}
template <class _A0, class _A1>
_LIBCPP_INLINE_VISIBILITY
__hash_value_type(const _A0& __a0, const _A1& __a1)
: __cc(__a0, __a1) {}
};
#endif
template <class _HashIterator> template <class _HashIterator>
class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator class _LIBCPP_TYPE_VIS_ONLY __hash_map_iterator
{ {
@ -660,49 +725,7 @@ public:
"Invalid allocator::value_type"); "Invalid allocator::value_type");
private: private:
#if __cplusplus >= 201103L typedef __hash_value_type<key_type, mapped_type> __value_type;
union __value_type
{
typedef typename unordered_map::value_type value_type;
typedef typename unordered_map::__nc_value_type __nc_value_type;
value_type __cc;
__nc_value_type __nc;
template <class ..._Args>
__value_type(_Args&& ...__args)
: __cc(std::forward<_Args>(__args)...) {}
__value_type(const __value_type& __v)
: __cc(__v.__cc) {}
__value_type(__value_type&& __v)
: __nc(std::move(__v.__nc)) {}
__value_type& operator=(const __value_type& __v)
{__nc = __v.__cc; return *this;}
__value_type& operator=(__value_type&& __v)
{__nc = std::move(__v.__nc); return *this;}
~__value_type() {__cc.~value_type();}
};
#else
struct __value_type
{
typedef typename unordered_map::value_type value_type;
value_type __cc;
__value_type() {}
template <class _A0>
__value_type(const _A0& __a0)
: __cc(__a0) {}
template <class _A0, class _A1>
__value_type(const _A0& __a0, const _A1& __a1)
: __cc(__a0, __a1) {}
};
#endif
typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher; typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher;
typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal; typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal;
typedef typename allocator_traits<allocator_type>::template typedef typename allocator_traits<allocator_type>::template
@ -1439,49 +1462,7 @@ public:
"Invalid allocator::value_type"); "Invalid allocator::value_type");
private: private:
#if __cplusplus >= 201103L typedef __hash_value_type<key_type, mapped_type> __value_type;
union __value_type
{
typedef typename unordered_multimap::value_type value_type;
typedef typename unordered_multimap::__nc_value_type __nc_value_type;
value_type __cc;
__nc_value_type __nc;
template <class ..._Args>
__value_type(_Args&& ...__args)
: __cc(std::forward<_Args>(__args)...) {}
__value_type(const __value_type& __v)
: __cc(std::move(__v.__cc)) {}
__value_type(__value_type&& __v)
: __nc(std::move(__v.__nc)) {}
__value_type& operator=(const __value_type& __v)
{__nc = __v.__cc; return *this;}
__value_type& operator=(__value_type&& __v)
{__nc = std::move(__v.__nc); return *this;}
~__value_type() {__cc.~value_type();}
};
#else
struct __value_type
{
typedef typename unordered_multimap::value_type value_type;
value_type __cc;
__value_type() {}
template <class _A0>
__value_type(const _A0& __a0)
: __cc(__a0) {}
template <class _A0, class _A1>
__value_type(const _A0& __a0, const _A1& __a1)
: __cc(__a0, __a1) {}
};
#endif
typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher; typedef __unordered_map_hasher<key_type, __value_type, hasher> __hasher;
typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal; typedef __unordered_map_equal<key_type, __value_type, key_equal> __key_equal;
typedef typename allocator_traits<allocator_type>::template typedef typename allocator_traits<allocator_type>::template

24
test/containers/associative/multimap/scary.pass.cpp Normal file
View File

@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <map>
// class map class multimap
// Extension: SCARY/N2913 iterator compatibility between map and multimap
#include <map>
int main()
{
typedef std::map<int, int> M1;
typedef std::multimap<int, int> M2;
M2::iterator i;
M1::iterator j = i;
}

24
test/containers/associative/multiset/scary.pass.cpp Normal file
View File

@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <set>
// class set class multiset
// Extension: SCARY/N2913 iterator compatibility between set and multiset
#include <set>
int main()
{
typedef std::set<int> M1;
typedef std::multiset<int> M2;
M2::iterator i;
M1::iterator j = i;
}

24
test/containers/unord/unord.multimap/scary.pass.cpp Normal file
View File

@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <unordered_map>
// class unordered_map class unordered_multimap
// Extension: SCARY/N2913 iterator compatibility between unordered_map and unordered_multimap
#include <unordered_map>
int main()
{
typedef std::unordered_map<int, int> M1;
typedef std::unordered_multimap<int, int> M2;
M2::iterator i;
M1::iterator j = i;
}

24
test/containers/unord/unord.multiset/scary.pass.cpp Normal file
View File

@ -0,0 +1,24 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <unordered_set>
// class unordered_set class unordered_multiset
// Extension: SCARY/N2913 iterator compatibility between unordered_set and unordered_multiset
#include <unordered_set>
int main()
{
typedef std::unordered_set<int> M1;
typedef std::unordered_multiset<int> M2;
M2::iterator i;
M1::iterator j = i;
}