Attachment #16233 for issue #30891

View | Details | Raw Unified | Return to issue 30891
Collapse All | Expand All




# define  hash_map      __WORKAROUND_RENAME(hash_map)
# define  hash_multimap __WORKAROUND_RENAME(hash_multimap)

#  define _STLP_KEY_PAIR _STLP_STD::pair< const _Key, _Tp >
#  define _STLP_HASHTABLE _STLP_STD::hashtable< _STLP_STD::pair < const _Key, _Tp >, _Key, _HashFcn, \
												_STLP_STD::_STLP_SELECT1ST( _STLP_KEY_PAIR,  _Key ), _EqualKey, _Alloc >
      _STLP_SELECT1ST( _STLP_KEY_PAIR,  _Key ), _EqualKey, _Alloc >

template <class _Key, class _Tp, __DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
          __DFL_TMPL_PARAM(_EqualKey,equal_to<_Key>),

class hash_map
{
private:
#ifndef _STLP_HASHTABLE
#error _STLP_HASHTABLE
#endif
  typedef _STLP_HASHTABLE _Ht;
  typedef hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self;
public:

  const_iterator end() const { return _M_ht.end(); }

public:
  _STLP_STD::pair<iterator,bool> insert(const value_type& __obj)
    { return _M_ht.insert_unique(__obj); }
#ifdef _STLP_MEMBER_TEMPLATES
  template <class _InputIterator>

  void insert(const_iterator __f, const_iterator __l)
    { _M_ht.insert_unique(__f, __l); }
#endif /*_STLP_MEMBER_TEMPLATES */
  _STLP_STD::pair<iterator,bool> insert_noresize(const value_type& __obj)
    { return _M_ht.insert_unique_noresize(__obj); }    

  iterator find(const key_type& __key) { return _M_ht.find(__key); }


  size_type count(const key_type& __key) const { return _M_ht.count(__key); }
  
  _STLP_STD::pair<iterator, iterator> equal_range(const key_type& __key)
    { return _M_ht.equal_range(__key); }
  _STLP_STD::pair<const_iterator, const_iterator>
  equal_range(const key_type& __key) const
    { return _M_ht.equal_range(__key); }





class hash_set
{
private:
  typedef _STLP_STD::hashtable<_Value, _Value, _HashFcn, _STLP_STD::_Identity<_Value>, 
                    _EqualKey, _Alloc> _Ht;
  typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
  typedef typename _Ht::iterator _ht_iterator;

  iterator end() const { return _M_ht.end(); }

public:
_STLP_STD::pair<iterator, bool> insert(const value_type& __obj)
    {
	  _STLP_STD::pair<_ht_iterator, bool> __p = _M_ht.insert_unique(__obj);
      return _STLP_STD::pair<iterator,bool>(__REINTERPRET_CAST(const iterator&, __p.first), __p.second);
    }
#ifdef _STLP_MEMBER_TEMPLATES
  template <class _InputIterator>

    {_M_ht.insert_unique(__f, __l); }

#endif /*_STLP_MEMBER_TEMPLATES */
_STLP_STD::pair<iterator, bool> insert_noresize(const value_type& __obj)
  {
    pair<_ht_iterator, bool> __p = 
      _M_ht.insert_unique_noresize(__obj);

# endif
  size_type count(const key_type& __key) const { return _M_ht.count(__key); }
  
_STLP_STD::pair<iterator, iterator> equal_range(const key_type& __key) const
    { return _M_ht.equal_range(__key); }

  size_type erase(const key_type& __key) {return _M_ht.erase(__key); }

Return to issue 30891

Lines 39-48 Link Here

(-)stlport/wntmsci8.pro/inc/stlport/stl/_hash_map.h (-8 / +10 lines)
39	# define hash_map __WORKAROUND_RENAME(hash_map)	39	# define hash_map __WORKAROUND_RENAME(hash_map)
40	# define hash_multimap __WORKAROUND_RENAME(hash_multimap)	40	# define hash_multimap __WORKAROUND_RENAME(hash_multimap)
41		41
42	# define _STLP_KEY_PAIR pair< const _Key, _Tp >	42	# define _STLP_KEY_PAIR _STLP_STD::pair< const _Key, _Tp >
43	# define _STLP_HASHTABLE hashtable \	43	# define _STLP_HASHTABLE _STLP_STD::hashtable< _STLP_STD::pair < const _Key, _Tp >, _Key, _HashFcn, \
44	< pair < const _Key, _Tp >, _Key, _HashFcn, \	44	_STLP_STD::_STLP_SELECT1ST( _STLP_KEY_PAIR, _Key ), _EqualKey, _Alloc >
45	_STLP_SELECT1ST( _STLP_KEY_PAIR, _Key ), _EqualKey, _Alloc >
46		45
47	template <class _Key, class _Tp, __DFL_TMPL_PARAM(_HashFcn,hash<_Key>),	46	template <class _Key, class _Tp, __DFL_TMPL_PARAM(_HashFcn,hash<_Key>),
48	__DFL_TMPL_PARAM(_EqualKey,equal_to<_Key>),	47	__DFL_TMPL_PARAM(_EqualKey,equal_to<_Key>),
Lines 50-55 Link Here
50	class hash_map	49	class hash_map
51	{	50	{
52	private:	51	private:
		52	#ifndef _STLP_HASHTABLE
		53	#error _STLP_HASHTABLE
		54	#endif
53	typedef _STLP_HASHTABLE _Ht;	55	typedef _STLP_HASHTABLE _Ht;
54	typedef hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self;	56	typedef hash_map<_Key, _Tp, _HashFcn, _EqualKey, _Alloc> _Self;
55	public:	57	public:
Lines 162-168 Link Here
162	const_iterator end() const { return _M_ht.end(); }	164	const_iterator end() const { return _M_ht.end(); }
163		165
164	public:	166	public:
165	pair<iterator,bool> insert(const value_type& __obj)	167	_STLP_STD::pair<iterator,bool> insert(const value_type& __obj)
166	{ return _M_ht.insert_unique(__obj); }	168	{ return _M_ht.insert_unique(__obj); }
167	#ifdef _STLP_MEMBER_TEMPLATES	169	#ifdef _STLP_MEMBER_TEMPLATES
168	template <class _InputIterator>	170	template <class _InputIterator>
Lines 175-181 Link Here
175	void insert(const_iterator __f, const_iterator __l)	177	void insert(const_iterator __f, const_iterator __l)
176	{ _M_ht.insert_unique(__f, __l); }	178	{ _M_ht.insert_unique(__f, __l); }
177	#endif /_STLP_MEMBER_TEMPLATES /	179	#endif /_STLP_MEMBER_TEMPLATES /
178	pair<iterator,bool> insert_noresize(const value_type& __obj)	180	_STLP_STD::pair<iterator,bool> insert_noresize(const value_type& __obj)
179	{ return _M_ht.insert_unique_noresize(__obj); }	181	{ return _M_ht.insert_unique_noresize(__obj); }
180		182
181	iterator find(const key_type& __key) { return _M_ht.find(__key); }	183	iterator find(const key_type& __key) { return _M_ht.find(__key); }
Lines 190-198 Link Here
190		192
191	size_type count(const key_type& __key) const { return _M_ht.count(__key); }	193	size_type count(const key_type& __key) const { return _M_ht.count(__key); }
192		194
193	pair<iterator, iterator> equal_range(const key_type& __key)	195	_STLP_STD::pair<iterator, iterator> equal_range(const key_type& __key)
194	{ return _M_ht.equal_range(__key); }	196	{ return _M_ht.equal_range(__key); }
195	pair<const_iterator, const_iterator>	197	_STLP_STD::pair<const_iterator, const_iterator>
196	equal_range(const key_type& __key) const	198	equal_range(const key_type& __key) const
197	{ return _M_ht.equal_range(__key); }	199	{ return _M_ht.equal_range(__key); }
198		200

Lines 45-51 Link Here

(-)stlport/wntmsci8.pro/inc/stlport/stl/_hash_set.h (-6 / +6 lines)
45	class hash_set	45	class hash_set
46	{	46	{
47	private:	47	private:
48	typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,	48	typedef _STLP_STD::hashtable<_Value, _Value, _HashFcn, _STLP_STD::_Identity<_Value>,
49	_EqualKey, _Alloc> _Ht;	49	_EqualKey, _Alloc> _Ht;
50	typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Self;	50	typedef hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Self;
51	typedef typename _Ht::iterator _ht_iterator;	51	typedef typename _Ht::iterator _ht_iterator;
Lines 158-167 Link Here
158	iterator end() const { return _M_ht.end(); }	158	iterator end() const { return _M_ht.end(); }
159		159
160	public:	160	public:
161	pair<iterator, bool> insert(const value_type& __obj)	161	_STLP_STD::pair<iterator, bool> insert(const value_type& __obj)
162	{	162	{
163	pair<_ht_iterator, bool> __p = _M_ht.insert_unique(__obj);	163	_STLP_STD::pair<_ht_iterator, bool> __p = _M_ht.insert_unique(__obj);
164	return pair<iterator,bool>(__REINTERPRET_CAST(const iterator&, __p.first), __p.second);	164	return _STLP_STD::pair<iterator,bool>(__REINTERPRET_CAST(const iterator&, __p.first), __p.second);
165	}	165	}
166	#ifdef _STLP_MEMBER_TEMPLATES	166	#ifdef _STLP_MEMBER_TEMPLATES
167	template <class _InputIterator>	167	template <class _InputIterator>
Lines 175-181 Link Here
175	{_M_ht.insert_unique(__f, __l); }	175	{_M_ht.insert_unique(__f, __l); }
176		176
177	#endif /_STLP_MEMBER_TEMPLATES /	177	#endif /_STLP_MEMBER_TEMPLATES /
178	pair<iterator, bool> insert_noresize(const value_type& __obj)	178	_STLP_STD::pair<iterator, bool> insert_noresize(const value_type& __obj)
179	{	179	{
180	pair<_ht_iterator, bool> __p =	180	pair<_ht_iterator, bool> __p =
181	_M_ht.insert_unique_noresize(__obj);	181	_M_ht.insert_unique_noresize(__obj);
Lines 190-196 Link Here
190	# endif	190	# endif
191	size_type count(const key_type& __key) const { return _M_ht.count(__key); }	191	size_type count(const key_type& __key) const { return _M_ht.count(__key); }
192		192
193	pair<iterator, iterator> equal_range(const key_type& __key) const	193	_STLP_STD::pair<iterator, iterator> equal_range(const key_type& __key) const
194	{ return _M_ht.equal_range(__key); }	194	{ return _M_ht.equal_range(__key); }
195		195
196	size_type erase(const key_type& __key) {return _M_ht.erase(__key); }	196	size_type erase(const key_type& __key) {return _M_ht.erase(__key); }