00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
#ifndef _GLIBCXX_DEBUG_SAFE_SEQUENCE_H
00032
#define _GLIBCXX_DEBUG_SAFE_SEQUENCE_H 1
00033
00034
#include <debug/debug.h>
00035
#include <debug/safe_base.h>
00036
00037
namespace __gnu_debug
00038 {
00039
template<
typename _Iterator,
typename _Sequence>
00040
class _Safe_iterator;
00041
00042
00043
00044
00045
00046
template<
typename _Type>
00047 class _Not_equal_to
00048 {
00049 _Type __value;
00050
00051
public:
00052
explicit _Not_equal_to(
const _Type& __v) : __value(__v) { }
00053
00054
bool
00055 operator()(
const _Type& __x)
const
00056
{
return __value != __x; }
00057 };
00058
00059
00060
00061
template<
typename _Iterator>
00062 class _After_nth_from
00063 {
00064
typedef typename std::iterator_traits<_Iterator>::difference_type
00065
difference_type;
00066
00067 _Iterator _M_base;
00068
difference_type _M_n;
00069
00070
public:
00071 _After_nth_from(
const difference_type& __n,
const _Iterator& __base)
00072 : _M_base(__base), _M_n(__n) { }
00073
00074
bool
00075 operator()(
const _Iterator& __x)
const
00076
{
return __x - _M_base >= _M_n; }
00077 };
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00095
template<
typename _Sequence>
00096 class _Safe_sequence :
public _Safe_sequence_base
00097 {
00098
public:
00099
00100
00101
00102
00103
00104
template<
typename _Predicate>
00105
void
00106 _M_invalidate_if(_Predicate __pred);
00107
00108
00109
00110
00111
template<
typename _Iterator>
00112
void
00113 _M_transfer_iter(
const _Safe_iterator<_Iterator, _Sequence>& __x);
00114 };
00115
00116
template<
typename _Sequence>
00117
template<
typename _Predicate>
00118
void
00119 _Safe_sequence<_Sequence>::
00120 _M_invalidate_if(_Predicate __pred)
00121 {
00122
typedef typename _Sequence::iterator iterator;
00123
typedef typename _Sequence::const_iterator const_iterator;
00124
00125
for (_Safe_iterator_base* __iter = _M_iterators; __iter; )
00126 {
00127 iterator* __victim = static_cast<iterator*>(__iter);
00128 __iter = __iter->_M_next;
00129
if (!__victim->_M_singular())
00130 {
00131
if (__pred(__victim->base()))
00132 __victim->_M_invalidate();
00133 }
00134 }
00135
00136
for (_Safe_iterator_base* __iter2 = _M_const_iterators; __iter2; )
00137 {
00138 const_iterator* __victim = static_cast<const_iterator*>(__iter2);
00139 __iter2 = __iter2->_M_next;
00140
if (!__victim->_M_singular())
00141 {
00142
if (__pred(__victim->base()))
00143 __victim->_M_invalidate();
00144 }
00145 }
00146 }
00147
00148
template<
typename _Sequence>
00149
template<
typename _Iterator>
00150
void
00151 _Safe_sequence<_Sequence>::
00152 _M_transfer_iter(
const _Safe_iterator<_Iterator, _Sequence>& __x)
00153 {
00154 _Safe_sequence_base* __from = __x._M_sequence;
00155
if (!__from)
00156
return;
00157
00158
typedef typename _Sequence::iterator iterator;
00159
typedef typename _Sequence::const_iterator const_iterator;
00160
00161
for (_Safe_iterator_base* __iter = __from->_M_iterators; __iter; )
00162 {
00163 iterator* __victim = static_cast<iterator*>(__iter);
00164 __iter = __iter->_M_next;
00165
if (!__victim->_M_singular() && __victim->base() == __x.base())
00166 __victim->_M_attach(static_cast<_Sequence*>(
this));
00167 }
00168
00169
for (_Safe_iterator_base* __iter2 = __from->_M_const_iterators;
00170 __iter2;)
00171 {
00172 const_iterator* __victim = static_cast<const_iterator*>(__iter2);
00173 __iter2 = __iter2->_M_next;
00174
if (!__victim->_M_singular() && __victim->base() == __x.base())
00175 __victim->_M_attach(static_cast<_Sequence*>(
this));
00176 }
00177 }
00178 }
00179
00180
#endif