epoc32/include/stdapis/stlport/stl/debug/_hashtable.h
author William Roberts <williamr@symbian.org>
Wed, 31 Mar 2010 12:27:01 +0100
branchSymbian2
changeset 3 e1b950c65cb4
parent 0 061f57f2323e
permissions -rw-r--r--
Attempt to represent the S^2->S^3 header reorganisation as a series of "hg rename" operations
williamr@2
     1
/*
williamr@2
     2
 *
williamr@2
     3
 * Copyright (c) 1994
williamr@2
     4
 * Hewlett-Packard Company
williamr@2
     5
 *
williamr@2
     6
 * Copyright (c) 1996,1997
williamr@2
     7
 * Silicon Graphics Computer Systems, Inc.
williamr@2
     8
 *
williamr@2
     9
 * Copyright (c) 1997
williamr@2
    10
 * Moscow Center for SPARC Technology
williamr@2
    11
 *
williamr@2
    12
 * Copyright (c) 1999 
williamr@2
    13
 * Boris Fomitchev
williamr@2
    14
 *
williamr@2
    15
 * This material is provided "as is", with absolutely no warranty expressed
williamr@2
    16
 * or implied. Any use is at your own risk.
williamr@2
    17
 *
williamr@2
    18
 * Permission to use or copy this software for any purpose is hereby granted 
williamr@2
    19
 * without fee, provided the above notices are retained on all copies.
williamr@2
    20
 * Permission to modify the code and to distribute modified code is granted,
williamr@2
    21
 * provided the above notices are retained, and a notice that the code was
williamr@2
    22
 * modified is included with the above copyright notice.
williamr@2
    23
 *
williamr@2
    24
 */
williamr@2
    25
williamr@2
    26
/* NOTE: This is an internal header file, included by other STL headers.
williamr@2
    27
 *   You should not attempt to use it directly.
williamr@2
    28
 */
williamr@2
    29
williamr@2
    30
#ifndef _STLP_INTERNAL_DBG_HASHTABLE_H
williamr@2
    31
#define _STLP_INTERNAL_DBG_HASHTABLE_H
williamr@2
    32
williamr@2
    33
// Hashtable class, used to implement the hashed associative containers
williamr@2
    34
// hash_set, hash_map, hash_multiset, and hash_multimap.
williamr@2
    35
williamr@2
    36
# include <stl/debug/_iterator.h>
williamr@2
    37
williamr@2
    38
#  undef  hashtable
williamr@2
    39
#  undef  _DBG_hashtable
williamr@2
    40
#  define _DBG_hashtable  hashtable
williamr@2
    41
williamr@2
    42
#  define _STLP_DBG_HT_SUPER \
williamr@2
    43
__WORKAROUND_DBG_RENAME(hashtable) <_Val, _Key, _HF, _ExK, _EqK, _All>
williamr@2
    44
williamr@2
    45
_STLP_BEGIN_NAMESPACE
williamr@2
    46
williamr@2
    47
# ifdef _STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS
williamr@2
    48
template <class _Val, class _Key, class _HF,
williamr@2
    49
          class _ExK, class _EqK, class _All>
williamr@2
    50
inline _Val*
williamr@2
    51
value_type(const  _DBG_iter_base< _STLP_DBG_HT_SUPER >&) {
williamr@2
    52
  return (_Val*)0;
williamr@2
    53
}
williamr@2
    54
williamr@2
    55
template <class _Val, class _Key, class _HF,
williamr@2
    56
          class _ExK, class _EqK, class _All>
williamr@2
    57
inline forward_iterator_tag
williamr@2
    58
iterator_category(const  _DBG_iter_base< _STLP_DBG_HT_SUPER >&) {
williamr@2
    59
  return forward_iterator_tag();
williamr@2
    60
}
williamr@2
    61
# endif
williamr@2
    62
williamr@2
    63
template <class _Val, class _Key, class _HF,
williamr@2
    64
          class _ExK, class _EqK, class _All>
williamr@2
    65
class _DBG_hashtable : public _STLP_DBG_HT_SUPER {
williamr@2
    66
  typedef _DBG_hashtable<_Val, _Key, _HF, _ExK, _EqK, _All> _Self;
williamr@2
    67
  typedef _STLP_DBG_HT_SUPER _Base;
williamr@2
    68
williamr@2
    69
public:
williamr@2
    70
  typedef _Key key_type;
williamr@2
    71
  typedef _HF hasher;
williamr@2
    72
  typedef _EqK key_equal;
williamr@2
    73
williamr@2
    74
  __IMPORT_CONTAINER_TYPEDEFS(_Base)
williamr@2
    75
williamr@2
    76
public:
williamr@2
    77
  typedef _DBG_iter<_Base, _Nonconst_traits<value_type> >  iterator;
williamr@2
    78
  typedef _DBG_iter<_Base, _Const_traits<value_type> > const_iterator;
williamr@2
    79
  typedef typename _Base::iterator _Base_iterator;
williamr@2
    80
  typedef typename _Base::const_iterator _Base_const_iterator;
williamr@2
    81
williamr@2
    82
protected:
williamr@2
    83
  void _Invalidate_all() {_M_iter_list._Invalidate_all();}
williamr@2
    84
williamr@2
    85
  void _Invalidate_iterator(const const_iterator& __it) { 
williamr@2
    86
    __invalidate_iterator(&_M_iter_list,__it); 
williamr@2
    87
  }
williamr@2
    88
  void _Invalidate_iterators(const const_iterator& __first, const const_iterator& __last) {
williamr@2
    89
    const_iterator __cur = __first;
williamr@2
    90
    while (__cur != __last) __invalidate_iterator(&_M_iter_list, __cur++); 
williamr@2
    91
  }
williamr@2
    92
williamr@2
    93
  const _Base* _Get_base() const { return (const _Base*)this; }
williamr@2
    94
  _Base* _Get_base() { return (_Base*)this; }
williamr@2
    95
williamr@2
    96
public:
williamr@2
    97
  _DBG_hashtable(size_type __n,
williamr@2
    98
		 const _HF&  __hf,
williamr@2
    99
		 const _EqK& __eql,
williamr@2
   100
		 const _ExK& __ext,
williamr@2
   101
		 const allocator_type& __a = allocator_type()):
williamr@2
   102
    _STLP_DBG_HT_SUPER(__n, __hf, __eql, __ext, __a),
williamr@2
   103
    _M_iter_list(_Get_base()) {}
williamr@2
   104
  
williamr@2
   105
  _DBG_hashtable(size_type __n,
williamr@2
   106
		 const _HF&    __hf,
williamr@2
   107
		 const _EqK&   __eql,
williamr@2
   108
		 const allocator_type& __a = allocator_type()):
williamr@2
   109
    
williamr@2
   110
    _STLP_DBG_HT_SUPER(__n, __hf, __eql, __a),
williamr@2
   111
    _M_iter_list(_Get_base()) {}
williamr@2
   112
  
williamr@2
   113
  _DBG_hashtable(const _Self& __ht):
williamr@2
   114
    _STLP_DBG_HT_SUPER(__ht),
williamr@2
   115
    _M_iter_list(_Get_base()) {}
williamr@2
   116
  
williamr@2
   117
  _Self& operator= (const _Self& __ht) {
williamr@2
   118
    _Invalidate_all();
williamr@2
   119
    _Base::operator=(__ht);
williamr@2
   120
    return *this;
williamr@2
   121
  }
williamr@2
   122
  
williamr@2
   123
  void swap(_Self& __ht)
williamr@2
   124
  {
williamr@2
   125
   _M_iter_list._Swap_owners(__ht._M_iter_list);
williamr@2
   126
   _Base::swap(__ht);
williamr@2
   127
  }
williamr@2
   128
williamr@2
   129
  iterator begin() { return iterator(&_M_iter_list, _Base::begin()); }
williamr@2
   130
  iterator end()   { return iterator(&_M_iter_list, _Base::end()); }
williamr@2
   131
williamr@2
   132
  const_iterator begin() const { return const_iterator(&_M_iter_list, _Base::begin()); }
williamr@2
   133
  const_iterator end() const { return const_iterator(&_M_iter_list, _Base::end()); }
williamr@2
   134
williamr@2
   135
  pair<iterator, bool> insert_unique(const value_type& __obj)
williamr@2
   136
  {
williamr@2
   137
    pair < _Base_iterator, bool> __res =
williamr@2
   138
      _Base::insert_unique(__obj);
williamr@2
   139
    return pair<iterator, bool> ( iterator(&_M_iter_list, __res.first), __res.second);
williamr@2
   140
  }
williamr@2
   141
williamr@2
   142
  iterator insert_equal(const value_type& __obj) {
williamr@2
   143
    return iterator(&_M_iter_list, _Base::insert_equal(__obj));
williamr@2
   144
  }
williamr@2
   145
  
williamr@2
   146
  pair<iterator, bool> insert_unique_noresize(const value_type& __obj) {
williamr@2
   147
    pair < _Base_iterator, bool> __res =
williamr@2
   148
      _Base::insert_unique_noresize(__obj);
williamr@2
   149
    return pair<iterator, bool> ( iterator(&_M_iter_list, __res.first), __res.second);
williamr@2
   150
  }
williamr@2
   151
  
williamr@2
   152
  iterator insert_equal_noresize(const value_type& __obj) {
williamr@2
   153
    return iterator(&_M_iter_list, _Base::insert_equal_noresize(__obj));
williamr@2
   154
  }
williamr@2
   155
  
williamr@2
   156
#ifdef _STLP_MEMBER_TEMPLATES
williamr@2
   157
  template <class _InputIterator>
williamr@2
   158
  void insert_unique(_InputIterator __f, _InputIterator __l) {
williamr@2
   159
    _Base::insert_unique(__f, __l);
williamr@2
   160
  }
williamr@2
   161
williamr@2
   162
  template <class _InputIterator>
williamr@2
   163
  void insert_equal(_InputIterator __f, _InputIterator __l){
williamr@2
   164
    _Base::insert_equal(__f, __l);
williamr@2
   165
  }
williamr@2
   166
williamr@2
   167
#else /* _STLP_MEMBER_TEMPLATES */
williamr@2
   168
williamr@2
   169
  void insert_unique(const value_type* __f, const value_type* __l) {
williamr@2
   170
    _Base::insert_unique(__f, __l);
williamr@2
   171
  }
williamr@2
   172
  
williamr@2
   173
  void insert_equal(const value_type* __f, const value_type* __l) {
williamr@2
   174
    _Base::insert_equal(__f, __l);
williamr@2
   175
  }
williamr@2
   176
  
williamr@2
   177
  void insert_unique(const_iterator __f, const_iterator __l) {
williamr@2
   178
    _Base::insert_unique(__f._M_iterator, __l._M_iterator);
williamr@2
   179
  }
williamr@2
   180
  
williamr@2
   181
  void insert_equal(const_iterator __f, const_iterator __l) {
williamr@2
   182
    _Base::insert_equal(__f._M_iterator, __l._M_iterator);
williamr@2
   183
  }
williamr@2
   184
#endif /*_STLP_MEMBER_TEMPLATES */
williamr@2
   185
  
williamr@2
   186
  iterator find(const key_type& __key) {
williamr@2
   187
    return iterator(&_M_iter_list, _Base::find(__key));
williamr@2
   188
  } 
williamr@2
   189
williamr@2
   190
  const_iterator find(const key_type& __key) const {
williamr@2
   191
    return const_iterator(&_M_iter_list, _Base::find(__key));
williamr@2
   192
  } 
williamr@2
   193
williamr@2
   194
  pair<iterator, iterator> 
williamr@2
   195
  equal_range(const key_type& __key) {
williamr@2
   196
    pair < _Base_iterator, _Base_iterator > __res =
williamr@2
   197
      _Base::equal_range(__key);
williamr@2
   198
    return pair<iterator,iterator> (iterator(&_M_iter_list,__res.first),
williamr@2
   199
				    iterator(&_M_iter_list,__res.second));
williamr@2
   200
  }
williamr@2
   201
williamr@2
   202
  pair<const_iterator, const_iterator> 
williamr@2
   203
  equal_range(const key_type& __key) const {
williamr@2
   204
    pair <  _Base_const_iterator, _Base_const_iterator > __res =
williamr@2
   205
      _Base::equal_range(__key);
williamr@2
   206
    return pair<const_iterator,const_iterator> (const_iterator(&_M_iter_list,__res.first),
williamr@2
   207
				    const_iterator(&_M_iter_list,__res.second));
williamr@2
   208
  }
williamr@2
   209
williamr@2
   210
  size_type erase(const key_type& __key) {
williamr@2
   211
    pair<const_iterator, const_iterator> __p = equal_range(__key);
williamr@2
   212
    size_type __n = distance(__p.first, __p.second);
williamr@2
   213
    _Invalidate_iterators(__p.first, __p.second);
williamr@2
   214
    _Base::erase(__p.first._M_iterator, __p.second._M_iterator);
williamr@2
   215
    return __n;
williamr@2
   216
  }
williamr@2
   217
williamr@2
   218
  void erase(const const_iterator& __it) {
williamr@2
   219
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list, __it))
williamr@2
   220
    _STLP_DEBUG_CHECK(_Dereferenceable(__it))
williamr@2
   221
    _Invalidate_iterator(__it);
williamr@2
   222
    _Base::erase(__it._M_iterator);
williamr@2
   223
  }
williamr@2
   224
  void erase(const_iterator __first, const_iterator __last) {
williamr@2
   225
    _STLP_DEBUG_CHECK(__check_if_owner(&_M_iter_list, __first)&&
williamr@2
   226
                      __check_if_owner(&_M_iter_list, __last))
williamr@2
   227
    _Invalidate_iterators(__first, __last);
williamr@2
   228
    _Base::erase(__first._M_iterator, __last._M_iterator);
williamr@2
   229
  }
williamr@2
   230
  void resize(size_type __num_elements_hint) {
williamr@2
   231
    _Base::resize(__num_elements_hint);
williamr@2
   232
  }
williamr@2
   233
  
williamr@2
   234
  void clear() {
williamr@2
   235
    _Invalidate_all();
williamr@2
   236
    _Base::clear();
williamr@2
   237
  }
williamr@2
   238
williamr@2
   239
private:
williamr@2
   240
  __owned_list _M_iter_list;
williamr@2
   241
williamr@2
   242
};
williamr@2
   243
williamr@2
   244
#define _STLP_TEMPLATE_HEADER template <class _Val, class _Key, class _HF, class _ExK, class _EqK, class _All>
williamr@2
   245
#define _STLP_TEMPLATE_CONTAINER _DBG_hashtable<_Val,_Key,_HF,_ExK,_EqK,_All>
williamr@2
   246
#define _STLP_TEMPLATE_CONTAINER_BASE hashtable<_Val,_Key,_HF,_ExK,_EqK,_All>
williamr@2
   247
#include <stl/debug/_relops_hash_cont.h>
williamr@2
   248
#undef _STLP_TEMPLATE_CONTAINER_BASE
williamr@2
   249
#undef _STLP_TEMPLATE_CONTAINER
williamr@2
   250
#undef _STLP_TEMPLATE_HEADER
williamr@2
   251
williamr@2
   252
_STLP_END_NAMESPACE
williamr@2
   253
#  undef  hashtable
williamr@2
   254
williamr@2
   255
#endif /* _STLP_INTERNAL_HASHTABLE_H */
williamr@2
   256
williamr@2
   257
// Local Variables:
williamr@2
   258
// mode:C++
williamr@2
   259
// End:
williamr@2
   260
williamr@2
   261