> The "hash_map" part of the name means they belong to "<unordered_map>", and the actual type is defined in that header.
Woops, Sorry I guess the name is used in both "std::__1::" in unordered_map and "__gnu_cxx::" in <ext/hash_map>. My intention in the changes was to forward declare "std::__1::__hash_map_iterator". On Sat, Feb 13, 2016 at 1:11 AM, Eric Fiselier <e...@efcs.ca> wrote: > > hash_map still looks broken to me. > > Uh oh, Sorry :-S. The original breakage was caused by the removal of a > typedef "hash_map" used, but I'm sure I fixed that. > > > should not they be prefixed with __gnu_cxx:: ? > > No, they are in the correct namespace. The "hash_map" part of the name > means they belong to "<unordered_map>", and the actual type is defined in > that header. > > Could you give me more information about the breakage your seeing? The > actual compiler diagnostics if possible? I also committed other sizable > changes to <__hash_table> in r260513 so that may be related. > > Let me know if you need this reverted. If possible I would like to hold > off, at least until more is known. > > /Eric > > On Fri, Feb 12, 2016 at 1:31 PM, Evgenii Stepanov < > eugeni.stepa...@gmail.com> wrote: > >> Hi, >> >> hash_map still looks broken to me. >> I don't have a simple reproducer, but these declarations in __hash_table: >> >> template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY >> __hash_map_iterator; >> template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY >> __hash_map_const_iterator; >> >> should not they be prefixed with __gnu_cxx:: ? >> >> Clang says that std::__1::__hash_const_iterator and >> __gnu_cxx::__hash_map_const_iterator are not friends and >> __non_const_iterator at ext/hash_map:432 is private. >> >> >> On Wed, Feb 10, 2016 at 12:46 PM, Eric Fiselier via cfe-commits >> <cfe-commits@lists.llvm.org> wrote: >> > Author: ericwf >> > Date: Wed Feb 10 14:46:23 2016 >> > New Revision: 260431 >> > >> > URL: http://llvm.org/viewvc/llvm-project?rev=260431&view=rev >> > Log: >> > Recommit r260012 - Cleanup node-type handling in the unordered >> containers. >> > >> > This time I kept <ext/hash_map> working! >> > >> > This patch is the first in a series of patches that's meant to better >> > support unordered_map. unordered_map has a special "value_type" that >> > differs from pair<const Key, Value>. In order to meet the >> EmplaceConstructible >> > and CopyInsertable requirements we need to teach __hash_table about this >> > special value_type. >> > >> > This patch creates a "__hash_node_types" traits class that contains >> > all of the typedefs needed by the unordered containers and it's >> iterators. >> > These typedefs include ones for each node type and node pointer type, >> > as well as special typedefs for "unordered_map"'s value type. >> > >> > As a result of this change all of the unordered containers now all >> support >> > incomplete types. >> > >> > As a drive-by fix I changed the difference_type in __hash_table to >> always >> > be ptrdiff_t. There is a corresponding change to size_type but it cannot >> > take affect until an ABI break. >> > >> > This patch will be followed up shortly with fixes for various >> unordered_map >> > bugs and problems. >> > >> > Added: >> > libcxx/trunk/test/libcxx/containers/unord/key_value_traits.pass.cpp >> > >> libcxx/trunk/test/std/containers/unord/iterator_difference_type.pass.cpp >> > >> libcxx/trunk/test/std/containers/unord/unord.map/incomplete_type.pass.cpp >> > >> libcxx/trunk/test/std/containers/unord/unord.multimap/incomplete.pass.cpp >> > >> libcxx/trunk/test/std/containers/unord/unord.multiset/incomplete.pass.cpp >> > libcxx/trunk/test/std/containers/unord/unord.set/incomplete.pass.cpp >> > Modified: >> > libcxx/trunk/include/__config >> > libcxx/trunk/include/__hash_table >> > libcxx/trunk/include/ext/hash_map >> > libcxx/trunk/include/unordered_map >> > >> > Modified: libcxx/trunk/include/__config >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__config?rev=260431&r1=260430&r2=260431&view=diff >> > >> ============================================================================== >> > --- libcxx/trunk/include/__config (original) >> > +++ libcxx/trunk/include/__config Wed Feb 10 14:46:23 2016 >> > @@ -42,6 +42,7 @@ >> > // Fix undefined behavior in how std::list stores it's linked nodes. >> > #define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB >> > #define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB >> > +#define _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE >> > #endif >> > >> > #define _LIBCPP_CONCAT1(_LIBCPP_X,_LIBCPP_Y) _LIBCPP_X##_LIBCPP_Y >> > >> > Modified: libcxx/trunk/include/__hash_table >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/__hash_table?rev=260431&r1=260430&r2=260431&view=diff >> > >> ============================================================================== >> > --- libcxx/trunk/include/__hash_table (original) >> > +++ libcxx/trunk/include/__hash_table Wed Feb 10 14:46:23 2016 >> > @@ -17,6 +17,7 @@ >> > #include <iterator> >> > #include <algorithm> >> > #include <cmath> >> > +#include <utility> >> > >> > #include <__undef_min_max> >> > #include <__undef___deallocate> >> > @@ -49,10 +50,10 @@ struct __hash_node >> > typename __rebind_pointer<_VoidPtr, __hash_node<_Tp, >> _VoidPtr> >::type >> > > >> > { >> > - typedef _Tp value_type; >> > + typedef _Tp __node_value_type; >> > >> > size_t __hash_; >> > - value_type __value_; >> > + __node_value_type __value_; >> > }; >> > >> > inline _LIBCPP_INLINE_VISIBILITY >> > @@ -77,23 +78,126 @@ __next_hash_pow2(size_t __n) >> > } >> > >> > template <class _Tp, class _Hash, class _Equal, class _Alloc> class >> __hash_table; >> > + >> > +template <class _NodePtr> class _LIBCPP_TYPE_VIS_ONLY >> __hash_iterator; >> > template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY >> __hash_const_iterator; >> > +template <class _NodePtr> class _LIBCPP_TYPE_VIS_ONLY >> __hash_local_iterator; >> > +template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY >> __hash_const_local_iterator; >> > template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY >> __hash_map_iterator; >> > template <class _HashIterator> class _LIBCPP_TYPE_VIS_ONLY >> __hash_map_const_iterator; >> > >> > +#if __cplusplus >= 201103L >> > +template <class _Key, class _Tp> >> > +union __hash_value_type; >> > +#else >> > +template <class _Key, class _Tp> >> > +struct __hash_value_type; >> > +#endif >> > + >> > +template <class _Tp> >> > +struct __key_value_types { >> > + static_assert(!is_reference<_Tp>::value && !is_const<_Tp>::value, >> ""); >> > + typedef _Tp key_type; >> > + typedef _Tp __node_value_type; >> > + typedef _Tp __container_value_type; >> > + static const bool __is_map = false; >> > +}; >> > + >> > +template <class _Key, class _Tp> >> > +struct __key_value_types<__hash_value_type<_Key, _Tp> > { >> > + typedef _Key key_type; >> > + typedef _Tp mapped_type; >> > + typedef __hash_value_type<_Key, _Tp> >> __node_value_type; >> > + typedef pair<const _Key, _Tp> >> __container_value_type; >> > + typedef __container_value_type >> __map_value_type; >> > + static const bool __is_map = true; >> > +}; >> > + >> > +template <class _Tp, class _AllocPtr, class _KVTypes = >> __key_value_types<_Tp>, >> > + bool = _KVTypes::__is_map> >> > +struct __map_pointer_types {}; >> > + >> > +template <class _Tp, class _AllocPtr, class _KVTypes> >> > +struct __map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> { >> > + typedef typename _KVTypes::__map_value_type _Mv; >> > + typedef typename __rebind_pointer<_AllocPtr, _Mv>::type >> > + >> __map_value_type_pointer; >> > + typedef typename __rebind_pointer<_AllocPtr, const _Mv>::type >> > + >> __const_map_value_type_pointer; >> > +}; >> > + >> > +template <class _NodePtr, class _NodeT = typename >> pointer_traits<_NodePtr>::element_type> >> > +struct __hash_node_types; >> > + >> > +template <class _NodePtr, class _Tp, class _VoidPtr> >> > +struct __hash_node_types<_NodePtr, __hash_node<_Tp, _VoidPtr> > >> > + : public __key_value_types<_Tp>, __map_pointer_types<_Tp, _VoidPtr> >> > + >> > +{ >> > + typedef __key_value_types<_Tp> __base; >> > + >> > +public: >> > + typedef ptrdiff_t difference_type; >> > + typedef size_t size_type; >> > + >> > + typedef typename __rebind_pointer<_NodePtr, void>::type >> __void_pointer; >> > + >> > + typedef typename pointer_traits<_NodePtr>::element_type >> __node_type; >> > + typedef _NodePtr >> __node_pointer; >> > + >> > + typedef __hash_node_base<__node_pointer> >> __node_base_type; >> > + typedef typename __rebind_pointer<_NodePtr, __node_base_type>::type >> > + >> __node_base_pointer; >> > + >> > + typedef _Tp >> __node_value_type; >> > + typedef typename __rebind_pointer<_VoidPtr, __node_value_type>::type >> > + >> __node_value_type_pointer; >> > + typedef typename __rebind_pointer<_VoidPtr, const >> __node_value_type>::type >> > + >> __const_node_value_type_pointer; >> > +private: >> > + static_assert(!is_const<__node_type>::value, >> > + "_NodePtr should never be a pointer to const"); >> > + static_assert((is_same<typename >> pointer_traits<_VoidPtr>::element_type, void>::value), >> > + "_VoidPtr does not point to unqualified void type"); >> > + static_assert((is_same<typename __rebind_pointer<_VoidPtr, >> __node_type>::type, >> > + _NodePtr>::value), "_VoidPtr does not rebind >> to _NodePtr."); >> > +}; >> > + >> > + >> > + >> > +template <class _HashIterator> >> > +struct __hash_node_types_from_iterator; >> > +template <class _NodePtr> >> > +struct __hash_node_types_from_iterator<__hash_iterator<_NodePtr> > : >> __hash_node_types<_NodePtr> {}; >> > +template <class _NodePtr> >> > +struct __hash_node_types_from_iterator<__hash_const_iterator<_NodePtr> >> > : __hash_node_types<_NodePtr> {}; >> > +template <class _NodePtr> >> > +struct __hash_node_types_from_iterator<__hash_local_iterator<_NodePtr> >> > : __hash_node_types<_NodePtr> {}; >> > +template <class _NodePtr> >> > +struct >> __hash_node_types_from_iterator<__hash_const_local_iterator<_NodePtr> > : >> __hash_node_types<_NodePtr> {}; >> > + >> > + >> > +template <class _NodeValueTp, class _VoidPtr> >> > +struct __make_hash_node_types { >> > + typedef __hash_node<_NodeValueTp, _VoidPtr> _NodeTp; >> > + typedef typename __rebind_pointer<_VoidPtr, _NodeTp>::type _NodePtr; >> > + typedef __hash_node_types<_NodePtr> type; >> > +}; >> > + >> > template <class _NodePtr> >> > class _LIBCPP_TYPE_VIS_ONLY __hash_iterator >> > { >> > - typedef _NodePtr __node_pointer; >> > + typedef __hash_node_types<_NodePtr> _NodeTypes; >> > + typedef _NodePtr __node_pointer; >> > >> > __node_pointer __node_; >> > >> > public: >> > - typedef forward_iterator_tag >> iterator_category; >> > - typedef typename >> pointer_traits<__node_pointer>::element_type::value_type value_type; >> > - typedef typename pointer_traits<__node_pointer>::difference_type >> difference_type; >> > - typedef value_type& reference; >> > - typedef typename __rebind_pointer<__node_pointer, >> value_type>::type pointer; >> > + typedef forward_iterator_tag >> iterator_category; >> > + typedef typename _NodeTypes::__node_value_type value_type; >> > + typedef typename _NodeTypes::difference_type >> difference_type; >> > + typedef value_type& reference; >> > + typedef typename _NodeTypes::__node_value_type_pointer pointer; >> > >> > _LIBCPP_INLINE_VISIBILITY __hash_iterator() _NOEXCEPT >> > #if _LIBCPP_STD_VER > 11 >> > @@ -202,25 +306,22 @@ private: >> > template <class, class, class, class, class> friend class >> _LIBCPP_TYPE_VIS_ONLY unordered_multimap; >> > }; >> > >> > -template <class _ConstNodePtr> >> > +template <class _NodePtr> >> > class _LIBCPP_TYPE_VIS_ONLY __hash_const_iterator >> > { >> > - typedef _ConstNodePtr __node_pointer; >> > - >> > - __node_pointer __node_; >> > - >> > - typedef typename remove_const< >> > - typename pointer_traits<__node_pointer>::element_type >> > - >::type __node; >> > + static_assert(!is_const<typename >> pointer_traits<_NodePtr>::element_type>::value, ""); >> > + typedef __hash_node_types<_NodePtr> _NodeTypes; >> > + typedef _NodePtr __node_pointer; >> > + typedef __hash_iterator<_NodePtr> __non_const_iterator; >> > + __node_pointer __node_; >> > >> > public: >> > - typedef forward_iterator_tag >> iterator_category; >> > - typedef typename __node::value_type value_type; >> > - typedef typename pointer_traits<__node_pointer>::difference_type >> difference_type; >> > - typedef const value_type& reference; >> > - typedef typename __rebind_pointer<__node_pointer, const >> value_type>::type pointer; >> > - typedef typename __rebind_pointer<__node_pointer, __node>::type >> __non_const_node_pointer; >> > - typedef __hash_iterator<__non_const_node_pointer> >> __non_const_iterator; >> > + typedef forward_iterator_tag >> iterator_category; >> > + typedef typename _NodeTypes::__node_value_type >> value_type; >> > + typedef typename _NodeTypes::difference_type >> difference_type; >> > + typedef const value_type& >> reference; >> > + typedef typename _NodeTypes::__const_node_value_type_pointer >> pointer; >> > + >> > >> > _LIBCPP_INLINE_VISIBILITY __hash_const_iterator() _NOEXCEPT >> > #if _LIBCPP_STD_VER > 11 >> > @@ -336,24 +437,22 @@ private: >> > template <class, class, class, class, class> friend class >> _LIBCPP_TYPE_VIS_ONLY unordered_multimap; >> > }; >> > >> > -template <class _ConstNodePtr> class _LIBCPP_TYPE_VIS_ONLY >> __hash_const_local_iterator; >> > - >> > template <class _NodePtr> >> > class _LIBCPP_TYPE_VIS_ONLY __hash_local_iterator >> > { >> > - typedef _NodePtr __node_pointer; >> > + typedef __hash_node_types<_NodePtr> _NodeTypes; >> > + typedef _NodePtr __node_pointer; >> > >> > __node_pointer __node_; >> > size_t __bucket_; >> > size_t __bucket_count_; >> > >> > - typedef pointer_traits<__node_pointer> __pointer_traits; >> > public: >> > typedef forward_iterator_tag >> iterator_category; >> > - typedef typename __pointer_traits::element_type::value_type >> value_type; >> > - typedef typename __pointer_traits::difference_type >> difference_type; >> > + typedef typename _NodeTypes::__node_value_type >> value_type; >> > + typedef typename _NodeTypes::difference_type >> difference_type; >> > typedef value_type& >> reference; >> > - typedef typename __rebind_pointer<__node_pointer, >> value_type>::type pointer; >> > + typedef typename _NodeTypes::__node_value_type_pointer >> pointer; >> > >> > _LIBCPP_INLINE_VISIBILITY __hash_local_iterator() _NOEXCEPT >> > { >> > @@ -476,7 +575,8 @@ private: >> > template <class _ConstNodePtr> >> > class _LIBCPP_TYPE_VIS_ONLY __hash_const_local_iterator >> > { >> > - typedef _ConstNodePtr __node_pointer; >> > + typedef __hash_node_types<_ConstNodePtr> _NodeTypes; >> > + typedef _ConstNodePtr __node_pointer; >> > >> > __node_pointer __node_; >> > size_t __bucket_; >> > @@ -491,14 +591,11 @@ class _LIBCPP_TYPE_VIS_ONLY __hash_const >> > typedef __hash_local_iterator<__non_const_node_pointer> >> > >> __non_const_iterator; >> > public: >> > - typedef forward_iterator_tag >> iterator_category; >> > - typedef typename remove_const< >> > - typename >> __pointer_traits::element_type::value_type >> > - >::type value_type; >> > - typedef typename __pointer_traits::difference_type difference_type; >> > - typedef const value_type& reference; >> > - typedef typename __rebind_pointer<__node_pointer, const >> value_type>::type >> > - pointer; >> > + typedef forward_iterator_tag >> iterator_category; >> > + typedef typename _NodeTypes::__node_value_type >> value_type; >> > + typedef typename _NodeTypes::difference_type >> difference_type; >> > + typedef const value_type& >> reference; >> > + typedef typename _NodeTypes::__const_node_value_type_pointer >> pointer; >> > >> > >> > _LIBCPP_INLINE_VISIBILITY __hash_const_local_iterator() _NOEXCEPT >> > @@ -686,7 +783,7 @@ class __hash_node_destructor >> > { >> > typedef _Alloc >> allocator_type; >> > typedef allocator_traits<allocator_type> >> __alloc_traits; >> > - typedef typename __alloc_traits::value_type::value_type value_type; >> > + >> > public: >> > typedef typename __alloc_traits::pointer pointer; >> > private: >> > @@ -728,23 +825,42 @@ public: >> > >> > private: >> > typedef allocator_traits<allocator_type> __alloc_traits; >> > + typedef typename >> > + __make_hash_node_types<value_type, typename >> __alloc_traits::void_pointer>::type >> > + >> _NodeTypes; >> > public: >> > typedef value_type& reference; >> > typedef const value_type& const_reference; >> > typedef typename __alloc_traits::pointer pointer; >> > typedef typename __alloc_traits::const_pointer const_pointer; >> > +#ifndef _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE >> > typedef typename __alloc_traits::size_type size_type; >> > - typedef typename __alloc_traits::difference_type difference_type; >> > +#else >> > + typedef typename _NodeTypes::size_type size_type; >> > +#endif >> > + typedef typename _NodeTypes::difference_type difference_type; >> > public: >> > // Create __node >> > - typedef __hash_node<value_type, typename >> __alloc_traits::void_pointer> __node; >> > + >> > + typedef typename _NodeTypes::__node_type __node; >> > typedef typename __rebind_alloc_helper<__alloc_traits, >> __node>::type __node_allocator; >> > typedef allocator_traits<__node_allocator> __node_traits; >> > - typedef typename __node_traits::pointer __node_pointer; >> > - typedef typename __node_traits::pointer >> __node_const_pointer; >> > - typedef __hash_node_base<__node_pointer> __first_node; >> > - typedef typename __rebind_pointer<__node_pointer, >> __first_node>::type >> > - __node_base_pointer; >> > + typedef typename _NodeTypes::__node_pointer __node_pointer; >> > + typedef typename _NodeTypes::__node_pointer >> __node_const_pointer; >> > + typedef typename _NodeTypes::__node_base_type __first_node; >> > + typedef typename _NodeTypes::__node_base_pointer >> __node_base_pointer; >> > + >> > +private: >> > + // check for sane allocator pointer rebinding semantics. Rebinding >> the >> > + // allocator for a new pointer type should be exactly the same as >> rebinding >> > + // the pointer using 'pointer_traits'. >> > + static_assert((is_same<__node_pointer, typename >> __node_traits::pointer>::value), >> > + "Allocator does not rebind pointers in a sane >> manner."); >> > + typedef typename __rebind_alloc_helper<__node_traits, >> __first_node>::type >> > + __node_base_allocator; >> > + typedef allocator_traits<__node_base_allocator> __node_base_traits; >> > + static_assert((is_same<__node_base_pointer, typename >> __node_base_traits::pointer>::value), >> > + "Allocator does not rebind pointers in a sane >> manner."); >> > >> > private: >> > >> > @@ -755,10 +871,10 @@ private: >> > typedef typename __bucket_list_deleter::pointer >> __node_pointer_pointer; >> > >> > // --- Member data begin --- >> > - __bucket_list __bucket_list_; >> > - __compressed_pair<__first_node, __node_allocator> __p1_; >> > - __compressed_pair<size_type, hasher> __p2_; >> > - __compressed_pair<float, key_equal> __p3_; >> > + __bucket_list >> __bucket_list_; >> > + __compressed_pair<__first_node, __node_allocator> __p1_; >> > + __compressed_pair<size_type, hasher> __p2_; >> > + __compressed_pair<float, key_equal> __p3_; >> > // --- Member data end --- >> > >> > _LIBCPP_INLINE_VISIBILITY >> > >> > Modified: libcxx/trunk/include/ext/hash_map >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/ext/hash_map?rev=260431&r1=260430&r2=260431&view=diff >> > >> ============================================================================== >> > --- libcxx/trunk/include/ext/hash_map (original) >> > +++ libcxx/trunk/include/ext/hash_map Wed Feb 10 14:46:23 2016 >> > @@ -309,7 +309,7 @@ class __hash_map_node_destructor >> > { >> > typedef _Alloc allocator_type; >> > typedef allocator_traits<allocator_type> __alloc_traits; >> > - typedef typename __alloc_traits::value_type::value_type value_type; >> > + typedef typename __alloc_traits::value_type::__node_value_type >> value_type; >> > public: >> > typedef typename __alloc_traits::pointer pointer; >> > private: >> > >> > Modified: libcxx/trunk/include/unordered_map >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/include/unordered_map?rev=260431&r1=260430&r2=260431&view=diff >> > >> ============================================================================== >> > --- libcxx/trunk/include/unordered_map (original) >> > +++ libcxx/trunk/include/unordered_map Wed Feb 10 14:46:23 2016 >> > @@ -384,6 +384,7 @@ template <class _Key, class _Cp, class _ >> > class __unordered_map_hasher >> > : private _Hash >> > { >> > + typedef typename __key_value_types<_Cp>::__map_value_type _PairT; >> > public: >> > _LIBCPP_INLINE_VISIBILITY >> > __unordered_map_hasher() >> > @@ -414,6 +415,7 @@ class __unordered_map_hasher<_Key, _Cp, >> > { >> > _Hash __hash_; >> > >> > + typedef typename __key_value_types<_Cp>::__map_value_type _PairT; >> > public: >> > _LIBCPP_INLINE_VISIBILITY >> > __unordered_map_hasher() >> > @@ -455,6 +457,7 @@ template <class _Key, class _Cp, class _ >> > class __unordered_map_equal >> > : private _Pred >> > { >> > + typedef typename __key_value_types<_Cp>::__map_value_type _PairT; >> > public: >> > _LIBCPP_INLINE_VISIBILITY >> > __unordered_map_equal() >> > @@ -488,6 +491,7 @@ class __unordered_map_equal<_Key, _Cp, _ >> > { >> > _Pred __pred_; >> > >> > + typedef typename __key_value_types<_Cp>::__map_value_type _PairT; >> > public: >> > _LIBCPP_INLINE_VISIBILITY >> > __unordered_map_equal() >> > @@ -508,6 +512,9 @@ public: >> > _LIBCPP_INLINE_VISIBILITY >> > bool operator()(const _Key& __x, const _Cp& __y) const >> > {return __pred_(__x, __y.__cc.first);} >> > + _LIBCPP_INLINE_VISIBILITY >> > + bool operator()(const _Key& __x, const _PairT& __y) const >> > + {return __pred_(__x, __y.first);} >> > void swap(__unordered_map_equal&__y) >> > _NOEXCEPT_(__is_nothrow_swappable<_Pred>::value) >> > { >> > @@ -531,12 +538,11 @@ class __hash_map_node_destructor >> > { >> > typedef _Alloc allocator_type; >> > typedef allocator_traits<allocator_type> __alloc_traits; >> > - typedef typename __alloc_traits::value_type::value_type value_type; >> > + >> > public: >> > - typedef typename __alloc_traits::pointer pointer; >> > + >> > + typedef typename __alloc_traits::pointer pointer; >> > private: >> > - typedef typename value_type::value_type::first_type first_type; >> > - typedef typename value_type::value_type::second_type >> second_type; >> > >> > allocator_type& __na_; >> > >> > @@ -656,15 +662,14 @@ class _LIBCPP_TYPE_VIS_ONLY __hash_map_i >> > { >> > _HashIterator __i_; >> > >> > - typedef const typename >> _HashIterator::value_type::value_type::first_type key_type; >> > - typedef typename >> _HashIterator::value_type::value_type::second_type mapped_type; >> > + typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes; >> > + >> > public: >> > typedef forward_iterator_tag >> iterator_category; >> > - typedef pair<key_type, mapped_type> >> value_type; >> > - typedef typename _HashIterator::difference_type >> difference_type; >> > + typedef typename _NodeTypes::__map_value_type >> value_type; >> > + typedef typename _NodeTypes::difference_type >> difference_type; >> > typedef value_type& >> reference; >> > - typedef typename __rebind_pointer<typename _HashIterator::pointer, >> value_type>::type >> > - pointer; >> > + typedef typename _NodeTypes::__map_value_type_pointer >> pointer; >> > >> > _LIBCPP_INLINE_VISIBILITY >> > __hash_map_iterator() _NOEXCEPT {} >> > @@ -706,15 +711,14 @@ class _LIBCPP_TYPE_VIS_ONLY __hash_map_c >> > { >> > _HashIterator __i_; >> > >> > - typedef const typename >> _HashIterator::value_type::value_type::first_type key_type; >> > - typedef typename >> _HashIterator::value_type::value_type::second_type mapped_type; >> > + typedef __hash_node_types_from_iterator<_HashIterator> _NodeTypes; >> > + >> > public: >> > typedef forward_iterator_tag >> iterator_category; >> > - typedef pair<key_type, mapped_type> >> value_type; >> > - typedef typename _HashIterator::difference_type >> difference_type; >> > + typedef typename _NodeTypes::__map_value_type >> value_type; >> > + typedef typename _NodeTypes::difference_type >> difference_type; >> > typedef const value_type& >> reference; >> > - typedef typename __rebind_pointer<typename _HashIterator::pointer, >> const value_type>::type >> > - pointer; >> > + typedef typename _NodeTypes::__const_map_value_type_pointer >> pointer; >> > >> > _LIBCPP_INLINE_VISIBILITY >> > __hash_map_const_iterator() _NOEXCEPT {} >> > @@ -796,8 +800,8 @@ private: >> > public: >> > typedef typename __alloc_traits::pointer pointer; >> > typedef typename __alloc_traits::const_pointer const_pointer; >> > - typedef typename __alloc_traits::size_type size_type; >> > - typedef typename __alloc_traits::difference_type difference_type; >> > + typedef typename __table::size_type size_type; >> > + typedef typename __table::difference_type difference_type; >> > >> > typedef __hash_map_iterator<typename __table::iterator> >> iterator; >> > typedef __hash_map_const_iterator<typename >> __table::const_iterator> const_iterator; >> > @@ -1641,11 +1645,14 @@ private: >> > typedef __hash_map_node_destructor<__node_allocator> _Dp; >> > typedef unique_ptr<__node, _Dp> >> __node_holder; >> > typedef allocator_traits<allocator_type> >> __alloc_traits; >> > + static_assert((is_same<typename __node_traits::size_type, >> > + typename __alloc_traits::size_type>::value), >> > + "Allocator uses different size_type for different >> types"); >> > public: >> > typedef typename __alloc_traits::pointer pointer; >> > typedef typename __alloc_traits::const_pointer const_pointer; >> > - typedef typename __alloc_traits::size_type size_type; >> > - typedef typename __alloc_traits::difference_type difference_type; >> > + typedef typename __table::size_type size_type; >> > + typedef typename __table::difference_type difference_type; >> > >> > typedef __hash_map_iterator<typename __table::iterator> >> iterator; >> > typedef __hash_map_const_iterator<typename >> __table::const_iterator> const_iterator; >> > >> > Added: >> libcxx/trunk/test/libcxx/containers/unord/key_value_traits.pass.cpp >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/libcxx/containers/unord/key_value_traits.pass.cpp?rev=260431&view=auto >> > >> ============================================================================== >> > --- libcxx/trunk/test/libcxx/containers/unord/key_value_traits.pass.cpp >> (added) >> > +++ libcxx/trunk/test/libcxx/containers/unord/key_value_traits.pass.cpp >> Wed Feb 10 14:46:23 2016 >> > @@ -0,0 +1,59 @@ >> > >> +//===----------------------------------------------------------------------===// >> > +// >> > +// 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. >> > +// >> > >> +//===----------------------------------------------------------------------===// >> > + >> > +#include <__hash_table> >> > +#include <unordered_map> >> > +#include <unordered_set> >> > +#include <type_traits> >> > + >> > +#include "test_macros.h" >> > +#include "min_allocator.h" >> > + >> > +void testKeyValueTrait() { >> > + { >> > + typedef int Tp; >> > + typedef std::__key_value_types<Tp> Traits; >> > + static_assert((std::is_same<Traits::key_type, int>::value), ""); >> > + static_assert((std::is_same<Traits::__node_value_type, >> Tp>::value), ""); >> > + static_assert((std::is_same<Traits::__container_value_type, >> Tp>::value), ""); >> > + static_assert(Traits::__is_map == false, ""); >> > + } >> > + { >> > + typedef std::pair<int, int> Tp; >> > + typedef std::__key_value_types<Tp> Traits; >> > + static_assert((std::is_same<Traits::key_type, Tp>::value), ""); >> > + static_assert((std::is_same<Traits::__node_value_type, >> Tp>::value), ""); >> > + static_assert((std::is_same<Traits::__container_value_type, >> Tp>::value), ""); >> > + static_assert(Traits::__is_map == false, ""); >> > + } >> > + { >> > + typedef std::pair<const int, int> Tp; >> > + typedef std::__key_value_types<Tp> Traits; >> > + static_assert((std::is_same<Traits::key_type, Tp>::value), ""); >> > + static_assert((std::is_same<Traits::__node_value_type, >> Tp>::value), ""); >> > + static_assert((std::is_same<Traits::__container_value_type, >> Tp>::value), ""); >> > + static_assert(Traits::__is_map == false, ""); >> > + } >> > + { >> > + typedef std::__hash_value_type<int, int> Tp; >> > + typedef std::__key_value_types<Tp> Traits; >> > + static_assert((std::is_same<Traits::key_type, int>::value), ""); >> > + static_assert((std::is_same<Traits::mapped_type, int>::value), ""); >> > + static_assert((std::is_same<Traits::__node_value_type, >> Tp>::value), ""); >> > + static_assert((std::is_same<Traits::__container_value_type, >> > + std::pair<const int, int> >::value), >> ""); >> > + static_assert((std::is_same<Traits::__map_value_type, >> > + std::pair<const int, int> >::value), >> ""); >> > + static_assert(Traits::__is_map == true, ""); >> > + } >> > +} >> > + >> > +int main() { >> > + testKeyValueTrait(); >> > +} >> > >> > Added: >> libcxx/trunk/test/std/containers/unord/iterator_difference_type.pass.cpp >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/iterator_difference_type.pass.cpp?rev=260431&view=auto >> > >> ============================================================================== >> > --- >> libcxx/trunk/test/std/containers/unord/iterator_difference_type.pass.cpp >> (added) >> > +++ >> libcxx/trunk/test/std/containers/unord/iterator_difference_type.pass.cpp >> Wed Feb 10 14:46:23 2016 >> > @@ -0,0 +1,154 @@ >> > >> +//===----------------------------------------------------------------------===// >> > +// >> > +// 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. >> > +// >> > >> +//===----------------------------------------------------------------------===// >> > + >> > +#include <unordered_map> >> > +#include <unordered_set> >> > +#include <type_traits> >> > + >> > +#include "test_macros.h" >> > +#include "min_allocator.h" >> > +#include "test_allocator.h" >> > + >> > + >> > +template <class Map, class ValueTp, class PtrT, class CPtrT> >> > +void testUnorderedMap() { >> > + typedef typename Map::difference_type Diff; >> > + { >> > + typedef typename Map::iterator It; >> > + static_assert((std::is_same<typename It::value_type, >> ValueTp>::value), ""); >> > + static_assert((std::is_same<typename It::reference, >> ValueTp&>::value), ""); >> > + static_assert((std::is_same<typename It::pointer, PtrT>::value), >> ""); >> > + static_assert((std::is_same<typename It::difference_type, >> Diff>::value), ""); >> > + } >> > + { >> > + typedef typename Map::const_iterator It; >> > + static_assert((std::is_same<typename It::value_type, >> ValueTp>::value), ""); >> > + static_assert((std::is_same<typename It::reference, ValueTp >> const&>::value), ""); >> > + static_assert((std::is_same<typename It::pointer, CPtrT>::value), >> ""); >> > + static_assert((std::is_same<typename It::difference_type, >> Diff>::value), ""); >> > + } >> > + { >> > + typedef typename Map::local_iterator It; >> > + static_assert((std::is_same<typename It::value_type, >> ValueTp>::value), ""); >> > + static_assert((std::is_same<typename It::reference, >> ValueTp&>::value), ""); >> > + static_assert((std::is_same<typename It::pointer, PtrT>::value), >> ""); >> > + static_assert((std::is_same<typename It::difference_type, >> Diff>::value), ""); >> > + } >> > + { >> > + typedef typename Map::const_local_iterator It; >> > + static_assert((std::is_same<typename It::value_type, >> ValueTp>::value), ""); >> > + static_assert((std::is_same<typename It::reference, ValueTp >> const&>::value), ""); >> > + static_assert((std::is_same<typename It::pointer, CPtrT>::value), >> ""); >> > + static_assert((std::is_same<typename It::difference_type, >> Diff>::value), ""); >> > + } >> > +} >> > + >> > + >> > +template <class Set, class ValueTp, class CPtrT> >> > +void testUnorderedSet() { >> > + static_assert((std::is_same<typename Set::iterator, >> > + typename Set::const_iterator>::value), >> ""); >> > + static_assert((std::is_same<typename Set::local_iterator, >> > + typename >> Set::const_local_iterator>::value), ""); >> > + typedef typename Set::difference_type Diff; >> > + { >> > + typedef typename Set::iterator It; >> > + static_assert((std::is_same<typename It::value_type, >> ValueTp>::value), ""); >> > + static_assert((std::is_same<typename It::reference, ValueTp >> const&>::value), ""); >> > + static_assert((std::is_same<typename It::pointer, CPtrT>::value), >> ""); >> > + static_assert((std::is_same<typename It::difference_type, >> Diff>::value), ""); >> > + >> > + } >> > + { >> > + typedef typename Set::local_iterator It; >> > + static_assert((std::is_same<typename It::value_type, >> ValueTp>::value), ""); >> > + static_assert((std::is_same<typename It::reference, ValueTp >> const&>::value), ""); >> > + static_assert((std::is_same<typename It::pointer, CPtrT>::value), >> ""); >> > + static_assert((std::is_same<typename It::difference_type, >> Diff>::value), ""); >> > + } >> > +} >> > + >> > +int main() { >> > + { >> > + typedef std::unordered_map<int, int> Map; >> > + typedef std::pair<const int, int> ValueTp; >> > + testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>(); >> > + } >> > + { >> > + typedef std::pair<const int, int> ValueTp; >> > + typedef test_allocator<ValueTp> Alloc; >> > + typedef std::unordered_map<int, int, std::hash<int>, >> std::equal_to<int>, Alloc> Map; >> > + testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>(); >> > + } >> > +#if TEST_STD_VER >= 11 >> > + { >> > + typedef std::pair<const int, int> ValueTp; >> > + typedef min_allocator<ValueTp> Alloc; >> > + typedef std::unordered_map<int, int, std::hash<int>, >> std::equal_to<int>, Alloc> Map; >> > + testUnorderedMap<Map, ValueTp, min_pointer<ValueTp>, >> min_pointer<const ValueTp>>(); >> > + } >> > +#endif >> > + { >> > + typedef std::unordered_multimap<int, int> Map; >> > + typedef std::pair<const int, int> ValueTp; >> > + testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>(); >> > + } >> > + { >> > + typedef std::pair<const int, int> ValueTp; >> > + typedef test_allocator<ValueTp> Alloc; >> > + typedef std::unordered_multimap<int, int, std::hash<int>, >> std::equal_to<int>, Alloc> Map; >> > + testUnorderedMap<Map, ValueTp, ValueTp*, ValueTp const*>(); >> > + } >> > +#if TEST_STD_VER >= 11 >> > + { >> > + typedef std::pair<const int, int> ValueTp; >> > + typedef min_allocator<ValueTp> Alloc; >> > + typedef std::unordered_multimap<int, int, std::hash<int>, >> std::equal_to<int>, Alloc> Map; >> > + testUnorderedMap<Map, ValueTp, min_pointer<ValueTp>, >> min_pointer<const ValueTp>>(); >> > + } >> > +#endif >> > + { >> > + typedef int ValueTp; >> > + typedef std::unordered_set<ValueTp> Set; >> > + testUnorderedSet<Set, ValueTp, ValueTp const*>(); >> > + } >> > + { >> > + typedef int ValueTp; >> > + typedef test_allocator<ValueTp> Alloc; >> > + typedef std::unordered_set<ValueTp, std::hash<ValueTp>, >> std::equal_to<ValueTp>, Alloc> Set; >> > + testUnorderedSet<Set, ValueTp, ValueTp const*>(); >> > + } >> > +#if TEST_STD_VER >= 11 >> > + { >> > + typedef int ValueTp; >> > + typedef min_allocator<ValueTp> Alloc; >> > + typedef std::unordered_set<ValueTp, std::hash<ValueTp>, >> std::equal_to<ValueTp>, Alloc> Set; >> > + testUnorderedSet<Set, ValueTp, min_pointer<const ValueTp>>(); >> > + } >> > +#endif >> > + { >> > + typedef int ValueTp; >> > + typedef std::unordered_multiset<ValueTp> Set; >> > + testUnorderedSet<Set, ValueTp, ValueTp const*>(); >> > + } >> > + { >> > + typedef int ValueTp; >> > + typedef test_allocator<ValueTp> Alloc; >> > + typedef std::unordered_multiset<ValueTp, std::hash<ValueTp>, >> std::equal_to<ValueTp>, Alloc> Set; >> > + testUnorderedSet<Set, ValueTp, ValueTp const*>(); >> > + } >> > +#if TEST_STD_VER >= 11 >> > + { >> > + typedef int ValueTp; >> > + typedef min_allocator<ValueTp> Alloc; >> > + typedef std::unordered_multiset<ValueTp, std::hash<ValueTp>, >> std::equal_to<ValueTp>, Alloc> Set; >> > + testUnorderedSet<Set, ValueTp, min_pointer<const ValueTp>>(); >> > + } >> > +#endif >> > +} >> > >> > Added: >> libcxx/trunk/test/std/containers/unord/unord.map/incomplete_type.pass.cpp >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.map/incomplete_type.pass.cpp?rev=260431&view=auto >> > >> ============================================================================== >> > --- >> libcxx/trunk/test/std/containers/unord/unord.map/incomplete_type.pass.cpp >> (added) >> > +++ >> libcxx/trunk/test/std/containers/unord/unord.map/incomplete_type.pass.cpp >> Wed Feb 10 14:46:23 2016 >> > @@ -0,0 +1,37 @@ >> > + >> > >> +//===----------------------------------------------------------------------===// >> > +// >> > +// 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> >> > + >> > +// Check that std::unordered_map and it's iterators can be >> instantiated with an incomplete >> > +// type. >> > + >> > +#include <unordered_map> >> > + >> > +template <class Tp> >> > +struct MyHash { >> > + MyHash() {} >> > + std::size_t operator()(Tp const&) const {return 42;} >> > +}; >> > + >> > +struct A { >> > + typedef std::unordered_map<A, A, MyHash<A> > Map; >> > + Map m; >> > + Map::iterator it; >> > + Map::const_iterator cit; >> > + Map::local_iterator lit; >> > + Map::const_local_iterator clit; >> > +}; >> > + >> > +inline bool operator==(A const& L, A const& R) { return &L == &R; } >> > + >> > +int main() { >> > + A a; >> > +} >> > >> > Added: >> libcxx/trunk/test/std/containers/unord/unord.multimap/incomplete.pass.cpp >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multimap/incomplete.pass.cpp?rev=260431&view=auto >> > >> ============================================================================== >> > --- >> libcxx/trunk/test/std/containers/unord/unord.multimap/incomplete.pass.cpp >> (added) >> > +++ >> libcxx/trunk/test/std/containers/unord/unord.multimap/incomplete.pass.cpp >> Wed Feb 10 14:46:23 2016 >> > @@ -0,0 +1,37 @@ >> > + >> > >> +//===----------------------------------------------------------------------===// >> > +// >> > +// 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> >> > + >> > +// Check that std::unordered_multimap and it's iterators can be >> instantiated with an incomplete >> > +// type. >> > + >> > +#include <unordered_map> >> > + >> > +template <class Tp> >> > +struct MyHash { >> > + MyHash() {} >> > + std::size_t operator()(Tp const&) const {return 42;} >> > +}; >> > + >> > +struct A { >> > + typedef std::unordered_multimap<A, A, MyHash<A> > Map; >> > + Map m; >> > + Map::iterator it; >> > + Map::const_iterator cit; >> > + Map::local_iterator lit; >> > + Map::const_local_iterator clit; >> > +}; >> > + >> > +inline bool operator==(A const& L, A const& R) { return &L == &R; } >> > + >> > +int main() { >> > + A a; >> > +} >> > >> > Added: >> libcxx/trunk/test/std/containers/unord/unord.multiset/incomplete.pass.cpp >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.multiset/incomplete.pass.cpp?rev=260431&view=auto >> > >> ============================================================================== >> > --- >> libcxx/trunk/test/std/containers/unord/unord.multiset/incomplete.pass.cpp >> (added) >> > +++ >> libcxx/trunk/test/std/containers/unord/unord.multiset/incomplete.pass.cpp >> Wed Feb 10 14:46:23 2016 >> > @@ -0,0 +1,38 @@ >> > + >> > + >> > >> +//===----------------------------------------------------------------------===// >> > +// >> > +// 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> >> > + >> > +// Check that std::unordered_multiset and it's iterators can be >> instantiated with an incomplete >> > +// type. >> > + >> > +#include <unordered_set> >> > + >> > +template <class Tp> >> > +struct MyHash { >> > + MyHash() {} >> > + std::size_t operator()(Tp const&) const {return 42;} >> > +}; >> > + >> > +struct A { >> > + typedef std::unordered_multiset<A, MyHash<A> > Map; >> > + Map m; >> > + Map::iterator it; >> > + Map::const_iterator cit; >> > + Map::local_iterator lit; >> > + Map::const_local_iterator clit; >> > +}; >> > + >> > +inline bool operator==(A const& L, A const& R) { return &L == &R; } >> > + >> > +int main() { >> > + A a; >> > +} >> > >> > Added: >> libcxx/trunk/test/std/containers/unord/unord.set/incomplete.pass.cpp >> > URL: >> http://llvm.org/viewvc/llvm-project/libcxx/trunk/test/std/containers/unord/unord.set/incomplete.pass.cpp?rev=260431&view=auto >> > >> ============================================================================== >> > --- >> libcxx/trunk/test/std/containers/unord/unord.set/incomplete.pass.cpp (added) >> > +++ >> libcxx/trunk/test/std/containers/unord/unord.set/incomplete.pass.cpp Wed >> Feb 10 14:46:23 2016 >> > @@ -0,0 +1,38 @@ >> > + >> > + >> > >> +//===----------------------------------------------------------------------===// >> > +// >> > +// 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> >> > + >> > +// Check that std::unordered_set and it's iterators can be >> instantiated with an incomplete >> > +// type. >> > + >> > +#include <unordered_set> >> > + >> > +template <class Tp> >> > +struct MyHash { >> > + MyHash() {} >> > + std::size_t operator()(Tp const&) const {return 42;} >> > +}; >> > + >> > +struct A { >> > + typedef std::unordered_set<A, MyHash<A> > Map; >> > + Map m; >> > + Map::iterator it; >> > + Map::const_iterator cit; >> > + Map::local_iterator lit; >> > + Map::const_local_iterator clit; >> > +}; >> > + >> > +inline bool operator==(A const& L, A const& R) { return &L == &R; } >> > + >> > +int main() { >> > + A a; >> > +} >> > >> > >> > _______________________________________________ >> > cfe-commits mailing list >> > cfe-commits@lists.llvm.org >> > http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits >> > >
_______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org http://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
