epoc32/include/stdapis/stlport/stl/debug/_iterator.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) 1997
williamr@2
     4
 * Moscow Center for SPARC Technology
williamr@2
     5
 *
williamr@2
     6
 * Copyright (c) 1999 
williamr@2
     7
 * Boris Fomitchev
williamr@2
     8
 *
williamr@2
     9
 * This material is provided "as is", with absolutely no warranty expressed
williamr@2
    10
 * or implied. Any use is at your own risk.
williamr@2
    11
 *
williamr@2
    12
 * Permission to use or copy this software for any purpose is hereby granted 
williamr@2
    13
 * without fee, provided the above notices are retained on all copies.
williamr@2
    14
 * Permission to modify the code and to distribute modified code is granted,
williamr@2
    15
 * provided the above notices are retained, and a notice that the code was
williamr@2
    16
 * modified is included with the above copyright notice.
williamr@2
    17
 *
williamr@2
    18
 */
williamr@2
    19
williamr@2
    20
#ifndef _STLP_DBG_ITERATOR_H
williamr@2
    21
# define _STLP_DBG_ITERATOR_H
williamr@2
    22
williamr@2
    23
# include <stl/_pair.h>
williamr@2
    24
# include <stl/_alloc.h>
williamr@2
    25
williamr@2
    26
# define _STLP_DBG_ALLOCATOR_SELECT( _Tp ) _STLP_DEFAULT_ALLOCATOR_SELECT( _Tp )
williamr@2
    27
williamr@2
    28
_STLP_BEGIN_NAMESPACE
williamr@2
    29
williamr@2
    30
//============================================================
williamr@2
    31
williamr@2
    32
template <class _Iterator>
williamr@2
    33
void _Decrement(_Iterator& __it, const bidirectional_iterator_tag &) {
williamr@2
    34
  --__it;
williamr@2
    35
}
williamr@2
    36
williamr@2
    37
template <class _Iterator>
williamr@2
    38
void _Decrement(_Iterator& __it, const random_access_iterator_tag &) {
williamr@2
    39
  --__it;
williamr@2
    40
}
williamr@2
    41
williamr@2
    42
template <class _Iterator>
williamr@2
    43
void _Decrement(_Iterator& __it, const forward_iterator_tag &) {
williamr@2
    44
  _STLP_ASSERT(0)
williamr@2
    45
}
williamr@2
    46
williamr@2
    47
template <class _Iterator>
williamr@2
    48
void _Advance(_Iterator&, ptrdiff_t, const forward_iterator_tag &) {
williamr@2
    49
  _STLP_ASSERT(0)
williamr@2
    50
}
williamr@2
    51
williamr@2
    52
template <class _Iterator>
williamr@2
    53
void _Advance(_Iterator& __it, ptrdiff_t, const bidirectional_iterator_tag &) {
williamr@2
    54
  _STLP_ASSERT(0)  
williamr@2
    55
}
williamr@2
    56
williamr@2
    57
template <class _Iterator>
williamr@2
    58
void _Advance(_Iterator& __it, ptrdiff_t __n, const random_access_iterator_tag &) {
williamr@2
    59
  __it += __n;
williamr@2
    60
}
williamr@2
    61
williamr@2
    62
template <class _Iterator>
williamr@2
    63
ptrdiff_t _DBG_distance(const _Iterator& __x, const _Iterator& __y, const random_access_iterator_tag &) {
williamr@2
    64
  return __x - __y;
williamr@2
    65
}
williamr@2
    66
williamr@2
    67
template <class _Iterator>
williamr@2
    68
ptrdiff_t _DBG_distance(const _Iterator&, const _Iterator&, const forward_iterator_tag &) {
williamr@2
    69
  _STLP_ASSERT(0)
williamr@2
    70
  return 0;
williamr@2
    71
}
williamr@2
    72
williamr@2
    73
template <class _Iterator>
williamr@2
    74
ptrdiff_t _DBG_distance(const _Iterator&, const _Iterator&, const bidirectional_iterator_tag &) {
williamr@2
    75
  _STLP_ASSERT(0)  
williamr@2
    76
  return 0;
williamr@2
    77
}
williamr@2
    78
williamr@2
    79
template <class _Iterator>
williamr@2
    80
bool _CompareIt(const _Iterator&, const _Iterator&, const forward_iterator_tag &) {
williamr@2
    81
  _STLP_ASSERT(0)
williamr@2
    82
  return false;
williamr@2
    83
}
williamr@2
    84
williamr@2
    85
template <class _Iterator>
williamr@2
    86
bool _CompareIt(const _Iterator&, const _Iterator&, const bidirectional_iterator_tag &) {
williamr@2
    87
  _STLP_ASSERT(0)  
williamr@2
    88
  return false;
williamr@2
    89
}
williamr@2
    90
williamr@2
    91
template <class _Iterator>
williamr@2
    92
bool _CompareIt(const _Iterator& __x, const _Iterator& __y, const random_access_iterator_tag &) {
williamr@2
    93
  return __x < __y;
williamr@2
    94
}
williamr@2
    95
williamr@2
    96
williamr@2
    97
template <class _Iterator>
williamr@2
    98
bool _Dereferenceable(_Iterator __it) {
williamr@2
    99
  return (__it._Get_container_ptr() !=0) && !(__it._M_iterator == (__it._Get_container_ptr())->end());
williamr@2
   100
}
williamr@2
   101
williamr@2
   102
williamr@2
   103
template <class _Iterator>
williamr@2
   104
bool _Incrementable(const _Iterator& __it, ptrdiff_t __n, const forward_iterator_tag &) {
williamr@2
   105
  return (__n == 1) && _Dereferenceable(__it);
williamr@2
   106
}
williamr@2
   107
williamr@2
   108
template <class _Iterator>
williamr@2
   109
bool _Incrementable(const _Iterator& __it, ptrdiff_t __n, const bidirectional_iterator_tag &) {
williamr@2
   110
  typedef typename _Iterator::_Container_type __container_type;
williamr@2
   111
  __container_type* __c = __it._Get_container_ptr();
williamr@2
   112
  return (__c!=0) && ((__n == 1 && __it._M_iterator != __c->end() ) ||
williamr@2
   113
    (__n == -1 && __it._M_iterator != __c->begin()));
williamr@2
   114
}
williamr@2
   115
williamr@2
   116
template <class _Iterator>
williamr@2
   117
bool _Incrementable(const _Iterator& __it, ptrdiff_t __n, const random_access_iterator_tag &) {
williamr@2
   118
  typedef typename _Iterator::_Container_type __container_type;
williamr@2
   119
  __container_type* __c = __it._Get_container_ptr();
williamr@2
   120
  if (!__c) return false;
williamr@2
   121
  ptrdiff_t __new_pos = (__it._M_iterator - __c->begin()) + __n;
williamr@2
   122
  return  (__new_pos >=0) && (__STATIC_CAST(typename __container_type::size_type,__new_pos) <=__c->size());
williamr@2
   123
}
williamr@2
   124
williamr@2
   125
williamr@2
   126
template <class _Container>
williamr@2
   127
struct _DBG_iter_base : public __owned_link {
williamr@2
   128
public:
williamr@2
   129
  typedef typename _Container::value_type value_type;
williamr@2
   130
  typedef typename _Container::reference  reference;
williamr@2
   131
  typedef typename _Container::pointer    pointer;
williamr@2
   132
  typedef ptrdiff_t difference_type;
williamr@2
   133
  //private:
williamr@2
   134
  typedef typename _Container::iterator        _Nonconst_iterator;
williamr@2
   135
  typedef typename _Container::const_iterator  _Const_iterator;
williamr@2
   136
  typedef _Container                     _Container_type;
williamr@2
   137
    
williamr@2
   138
# ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
williamr@2
   139
  typedef typename iterator_traits<_Const_iterator>::iterator_category _Iterator_category;
williamr@2
   140
# else
williamr@2
   141
  typedef typename _Container::_Iterator_category  _Iterator_category;
williamr@2
   142
# endif
williamr@2
   143
  typedef _Iterator_category iterator_category;
williamr@2
   144
williamr@2
   145
  _DBG_iter_base() : __owned_link(0)  {}
williamr@2
   146
  _DBG_iter_base(const __owned_list* __c, const _Const_iterator& __it) :
williamr@2
   147
# ifdef __HP_aCC
williamr@2
   148
    __owned_link(__c), _M_iterator(*__REINTERPRET_CAST(const _Nonconst_iterator *, &__it)) {}
williamr@2
   149
# else
williamr@2
   150
    __owned_link(__c), _M_iterator(*(const _Nonconst_iterator*)&__it) {}
williamr@2
   151
# endif  
williamr@2
   152
  _Container* _Get_container_ptr() const { 
williamr@2
   153
    return (_Container*)__stl_debugger::_Get_container_ptr(this); 
williamr@2
   154
  }
williamr@2
   155
williamr@2
   156
  void __increment() {
williamr@2
   157
    _STLP_DEBUG_CHECK(_Incrementable(*this,1,_Iterator_category()))
williamr@2
   158
    ++_M_iterator;
williamr@2
   159
  }
williamr@2
   160
  
williamr@2
   161
  void __decrement() {
williamr@2
   162
    _STLP_DEBUG_CHECK(_Incrementable(*this,-1,_Iterator_category()))
williamr@2
   163
    _Decrement(_M_iterator, _Iterator_category());
williamr@2
   164
  }
williamr@2
   165
williamr@2
   166
  void __advance(difference_type __n) {
williamr@2
   167
    _STLP_DEBUG_CHECK(_Incrementable(*this,__n, _Iterator_category()))
williamr@2
   168
    _Advance(_M_iterator,__n, _Iterator_category());
williamr@2
   169
  }
williamr@2
   170
williamr@2
   171
// protected:
williamr@2
   172
  _Nonconst_iterator _M_iterator;
williamr@2
   173
};
williamr@2
   174
williamr@2
   175
template <class _Container>
williamr@2
   176
ptrdiff_t operator-(const _DBG_iter_base<_Container>& __x,
williamr@2
   177
                    const _DBG_iter_base<_Container>& __y ) {
williamr@2
   178
  typedef typename _DBG_iter_base<_Container>::_Iterator_category  _Iterator_category;
williamr@2
   179
  _STLP_DEBUG_CHECK(__check_same_owner(__x, __y))
williamr@2
   180
  return _DBG_distance(__x._M_iterator,__y._M_iterator, _Iterator_category());
williamr@2
   181
}
williamr@2
   182
williamr@2
   183
template <class _Container, class _Traits>
williamr@2
   184
struct _DBG_iter_mid : public _DBG_iter_base<_Container>
williamr@2
   185
{
williamr@2
   186
  typedef _DBG_iter_mid<_Container, typename _Traits::_Non_const_traits> _Nonconst_self;
williamr@2
   187
  typedef typename _Container::iterator        _Nonconst_iterator;
williamr@2
   188
  typedef typename _Container::const_iterator  _Const_iterator;
williamr@2
   189
williamr@2
   190
  _DBG_iter_mid() {}
williamr@2
   191
williamr@2
   192
  explicit _DBG_iter_mid(const _Nonconst_self& __it) :
williamr@2
   193
      _DBG_iter_base<_Container>(__it) {}
williamr@2
   194
        
williamr@2
   195
  _DBG_iter_mid(const __owned_list* __c, const _Const_iterator& __it) :
williamr@2
   196
      _DBG_iter_base<_Container>(__c, __it) {}
williamr@2
   197
};
williamr@2
   198
williamr@2
   199
template <class _Container, class _Traits>
williamr@2
   200
struct _DBG_iter : public _DBG_iter_mid<_Container, _Traits> {
williamr@2
   201
  typedef _DBG_iter_base<_Container>          _Base;
williamr@2
   202
public:
williamr@2
   203
  typedef typename _Base::value_type value_type;
williamr@2
   204
  typedef typename _Base::difference_type difference_type;    
williamr@2
   205
  typedef typename _Traits::reference  reference;
williamr@2
   206
  typedef typename _Traits::pointer    pointer;
williamr@2
   207
williamr@2
   208
private:
williamr@2
   209
  typedef typename _Base::_Nonconst_iterator _Nonconst_iterator;
williamr@2
   210
  typedef typename _Base::_Const_iterator _Const_iterator;
williamr@2
   211
williamr@2
   212
  typedef _DBG_iter<_Container, _Traits>     _Self;
williamr@2
   213
  typedef _DBG_iter_mid<_Container, typename _Traits::_Non_const_traits> _Nonconst_mid;
williamr@2
   214
williamr@2
   215
public:
williamr@2
   216
williamr@2
   217
# ifdef _STLP_CLASS_PARTIAL_SPECIALIZATION
williamr@2
   218
  typedef typename _Base::iterator_category iterator_category;
williamr@2
   219
# endif
williamr@2
   220
  typedef typename _Base::_Iterator_category  _Iterator_category;
williamr@2
   221
    
williamr@2
   222
public:
williamr@2
   223
  _DBG_iter() {}
williamr@2
   224
    // boris : real type of iter would be nice
williamr@2
   225
  _DBG_iter(const __owned_list* __c, const _Const_iterator& __it) :
williamr@2
   226
    _DBG_iter_mid<_Container, _Traits>(__c, __it) {}
williamr@2
   227
williamr@2
   228
  // This allows conversions from iterator to const_iterator without being
williamr@2
   229
  // redundant with the copy constructor below.
williamr@2
   230
  _DBG_iter(const _Nonconst_mid& __rhs) :
williamr@2
   231
    _DBG_iter_mid<_Container, _Traits>(__rhs) {}
williamr@2
   232
williamr@2
   233
  _DBG_iter(const  _Self& __rhs) :
williamr@2
   234
    _DBG_iter_mid<_Container, _Traits>(__rhs) {}
williamr@2
   235
  
williamr@2
   236
  // This allows conversions from iterator to const_iterator without being
williamr@2
   237
  // redundant with the copy assignment operator below.
williamr@2
   238
  _Self& operator=(const _Nonconst_mid& __rhs)  
williamr@2
   239
  {
williamr@2
   240
    (_Base&)*this = __rhs;
williamr@2
   241
    return *this;
williamr@2
   242
  }
williamr@2
   243
williamr@2
   244
  _Self& operator=(const  _Self& __rhs) 
williamr@2
   245
  {
williamr@2
   246
    (_Base&)*this = __rhs;
williamr@2
   247
    return *this;
williamr@2
   248
  }
williamr@2
   249
  
williamr@2
   250
  reference operator*() const {
williamr@2
   251
    _STLP_DEBUG_CHECK(_Dereferenceable(*this))
williamr@2
   252
    return *this->_M_iterator;
williamr@2
   253
  }
williamr@2
   254
williamr@2
   255
  _STLP_DEFINE_ARROW_OPERATOR
williamr@2
   256
  
williamr@2
   257
  _Self& operator++() {
williamr@2
   258
    this->__increment();
williamr@2
   259
    return *this;
williamr@2
   260
  }
williamr@2
   261
  _Self operator++(int) {
williamr@2
   262
    _Self __tmp = *this;
williamr@2
   263
    this->__increment();
williamr@2
   264
    return __tmp;
williamr@2
   265
  }
williamr@2
   266
  _Self& operator--() {
williamr@2
   267
    this->__decrement();
williamr@2
   268
    return *this;
williamr@2
   269
  }
williamr@2
   270
  _Self operator--(int) {
williamr@2
   271
    _Self __tmp = *this;
williamr@2
   272
    this->__decrement();
williamr@2
   273
    return __tmp;
williamr@2
   274
  }
williamr@2
   275
  
williamr@2
   276
  _Self& operator+=(difference_type __n) {
williamr@2
   277
    this->__advance(__n);
williamr@2
   278
    return *this;
williamr@2
   279
  }
williamr@2
   280
  
williamr@2
   281
  _Self& operator-=(difference_type __n) {
williamr@2
   282
    this->__advance(-__n);
williamr@2
   283
    return *this;
williamr@2
   284
  }
williamr@2
   285
  _Self operator+(difference_type __n) const {
williamr@2
   286
    _Self __tmp(*this);
williamr@2
   287
    __tmp.__advance(__n);
williamr@2
   288
    return __tmp;
williamr@2
   289
  }
williamr@2
   290
  _Self operator-(difference_type __n) const {
williamr@2
   291
    _Self __tmp(*this);
williamr@2
   292
    __tmp.__advance(-__n);
williamr@2
   293
    return __tmp;
williamr@2
   294
  }
williamr@2
   295
  reference operator[](difference_type __n) const { return *(*this + __n); }
williamr@2
   296
};
williamr@2
   297
williamr@2
   298
template <class _Container>
williamr@2
   299
inline bool 
williamr@2
   300
operator==(const _DBG_iter_base<_Container>& __x, const _DBG_iter_base<_Container>& __y) {
williamr@2
   301
  _STLP_DEBUG_CHECK(__check_same_owner_or_null(__x, __y))
williamr@2
   302
  return __x._M_iterator==__y._M_iterator;
williamr@2
   303
}
williamr@2
   304
williamr@2
   305
template <class _Container>
williamr@2
   306
inline bool 
williamr@2
   307
operator<(const _DBG_iter_base<_Container>& __x, const _DBG_iter_base<_Container>& __y) {
williamr@2
   308
  _STLP_DEBUG_CHECK(__check_same_owner_or_null(__x, __y))
williamr@2
   309
  typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
williamr@2
   310
  return _CompareIt(__x._M_iterator , __y._M_iterator, _Category());
williamr@2
   311
}
williamr@2
   312
williamr@2
   313
template <class _Container>
williamr@2
   314
inline bool 
williamr@2
   315
operator>(const _DBG_iter_base<_Container>& __x,
williamr@2
   316
	  const _DBG_iter_base<_Container>& __y) { 
williamr@2
   317
  typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
williamr@2
   318
  return _CompareIt(__y._M_iterator , __x._M_iterator, _Category());
williamr@2
   319
}
williamr@2
   320
williamr@2
   321
template <class _Container>
williamr@2
   322
inline bool 
williamr@2
   323
operator>=(const _DBG_iter_base<_Container>& __x, const _DBG_iter_base<_Container>& __y) {
williamr@2
   324
  _STLP_DEBUG_CHECK(__check_same_owner_or_null(__x, __y))
williamr@2
   325
  typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
williamr@2
   326
  return !_CompareIt(__x._M_iterator , __y._M_iterator, _Category());
williamr@2
   327
}
williamr@2
   328
williamr@2
   329
template <class _Container>
williamr@2
   330
inline bool 
williamr@2
   331
operator<=(const _DBG_iter_base<_Container>& __x,
williamr@2
   332
	  const _DBG_iter_base<_Container>& __y) {
williamr@2
   333
  typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category; 
williamr@2
   334
  return !_CompareIt(__y._M_iterator , __x._M_iterator, _Category());
williamr@2
   335
}
williamr@2
   336
williamr@2
   337
template <class _Container>
williamr@2
   338
inline bool 
williamr@2
   339
operator!=(const _DBG_iter_base<_Container>& __x, 
williamr@2
   340
	   const _DBG_iter_base<_Container>& __y) {
williamr@2
   341
  _STLP_DEBUG_CHECK(__check_same_owner_or_null(__x, __y))
williamr@2
   342
  return __x._M_iterator != __y._M_iterator;
williamr@2
   343
}
williamr@2
   344
williamr@2
   345
//------------------------------------------
williamr@2
   346
williamr@2
   347
template <class _Container, class _Traits>
williamr@2
   348
inline _DBG_iter<_Container, _Traits> 
williamr@2
   349
operator+(ptrdiff_t __n, const _DBG_iter<_Container, _Traits>& __it) {
williamr@2
   350
    _DBG_iter<_Container, _Traits> __tmp(__it);
williamr@2
   351
    return __tmp += __n;
williamr@2
   352
}
williamr@2
   353
williamr@2
   354
williamr@2
   355
# ifdef _STLP_USE_OLD_HP_ITERATOR_QUERIES
williamr@2
   356
# if defined (_STLP_NESTED_TYPE_PARAM_BUG) \
williamr@2
   357
   || ( defined (__SUNPRO_CC) && __SUNPRO_CC < 0x600) \
williamr@2
   358
   || ( defined (_STLP_MSVC) && (_STLP_MSVC < 1100) )
williamr@2
   359
#  define _STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS 1
williamr@2
   360
# endif
williamr@2
   361
williamr@2
   362
template <class _Container>
williamr@2
   363
inline ptrdiff_t* 
williamr@2
   364
distance_type(const  _DBG_iter_base<_Container>&) { return (ptrdiff_t*) 0; }
williamr@2
   365
williamr@2
   366
# if !defined (_STLP_DEBUG_USE_DISTINCT_VALUE_TYPE_HELPERS)
williamr@2
   367
template <class _Container>
williamr@2
   368
inline _STLP_TYPENAME_ON_RETURN_TYPE _DBG_iter_base<_Container>::value_type*
williamr@2
   369
value_type(const  _DBG_iter_base<_Container>&) {
williamr@2
   370
  typedef typename _DBG_iter_base<_Container>::value_type _Val;
williamr@2
   371
  return (_Val*)0;
williamr@2
   372
}
williamr@2
   373
williamr@2
   374
template <class _Container>
williamr@2
   375
inline _STLP_TYPENAME_ON_RETURN_TYPE _DBG_iter_base<_Container>::_Iterator_category 
williamr@2
   376
iterator_category(const  _DBG_iter_base<_Container>&) {
williamr@2
   377
  typedef typename _DBG_iter_base<_Container>::_Iterator_category _Category;
williamr@2
   378
  return _Category();
williamr@2
   379
}
williamr@2
   380
# endif
williamr@2
   381
williamr@2
   382
#  endif /* _STLP_USE_OLD_HP_ITERATOR_QUERIES */
williamr@2
   383
williamr@2
   384
# define _Get_iter(__x)   __x
williamr@2
   385
# define _Debug_iter(__x, __y) __y
williamr@2
   386
williamr@2
   387
_STLP_END_NAMESPACE
williamr@2
   388
williamr@2
   389
#endif /* INTERNAL_H */
williamr@2
   390
williamr@2
   391
// Local Variables:
williamr@2
   392
// mode:C++
williamr@2
   393
// End:
williamr@2
   394