#include <_rope.h>

Inheritance diagram for _Rope_iterator_base< _CharT, _Alloc >:

Collaboration diagram for _Rope_iterator_base< _CharT, _Alloc >:

[legend]

Public Types
enum	{ _S_path_cache_len = 4 }

enum	{ _S_iterator_buf_len = 15 }

typedef _Rope_RopeRep< _CharT, _Alloc >	_RopeRep

Public Member Functions
	_Rope_iterator_base ()

	_Rope_iterator_base (_RopeRep *__root, size_t __pos)

void	_M_incr (size_t __n)

void	_M_decr (size_t __n)

size_t	index () const

	_Rope_iterator_base (const _Self &__x)

_Self &	operator= (const _Self &__x)

Static Public Member Functions
static void	_S_setbuf (_Rope_iterator_base< _CharT, _Alloc > &__x)

static void	_S_setcache (_Rope_iterator_base< _CharT, _Alloc > &__x)

static void	_S_setcache_for_incr (_Rope_iterator_base< _CharT, _Alloc > &__x)

Public Attributes
size_t	_M_current_pos

_RopeRep *	_M_root

size_t	_M_leaf_pos

_CharT *	_M_buf_start

_CharT *	_M_buf_ptr

_CharT *	_M_buf_end

struct {
_RopeRep const * _M_data [_S_path_cache_len]

}	_M_path_end

int	_M_leaf_index

unsigned char	_M_path_directions

struct {
_CharT _M_data [_S_iterator_buf_len]

}	_M_tmp_buf

Private Types
typedef _Rope_iterator_base< _CharT, _Alloc >	_Self

typedef _Rope_RopeConcatenation< _CharT, _Alloc >	_RopeConcat

Private Member Functions
void	_M_copy_buf (const _Self &__x)

Friends
class	rope< _CharT, _Alloc >

Detailed Description

template<class _CharT, class _Alloc>
class _Rope_iterator_base< _CharT, _Alloc >

Definition at line 753 of file _rope.h.

Member Typedef Documentation

◆ _RopeConcat

template<class _CharT , class _Alloc >

typedef _Rope_RopeConcatenation<_CharT,_Alloc> _Rope_iterator_base< _CharT, _Alloc >::_RopeConcat

private

Definition at line 758 of file _rope.h.

◆ _RopeRep

template<class _CharT , class _Alloc >

typedef _Rope_RopeRep<_CharT,_Alloc> _Rope_iterator_base< _CharT, _Alloc >::_RopeRep

Definition at line 760 of file _rope.h.

◆ _Self

template<class _CharT , class _Alloc >

typedef _Rope_iterator_base<_CharT, _Alloc> _Rope_iterator_base< _CharT, _Alloc >::_Self

private

Definition at line 757 of file _rope.h.

Member Enumeration Documentation

◆ anonymous enum

template<class _CharT , class _Alloc >

anonymous enum

Enumerator
_S_path_cache_len

Definition at line 762 of file _rope.h.

762{ _S_path_cache_len = 4 }; // Must be <= 9 because of _M_path_direction.

_Rope_iterator_base::_S_path_cache_len

@ _S_path_cache_len

Definition: _rope.h:762

◆ anonymous enum

template<class _CharT , class _Alloc >

anonymous enum

Enumerator
_S_iterator_buf_len

Definition at line 763 of file _rope.h.

763{ _S_iterator_buf_len = 15 };

_Rope_iterator_base::_S_iterator_buf_len

@ _S_iterator_buf_len

Definition: _rope.h:763

Constructor & Destructor Documentation

◆ _Rope_iterator_base() [1/3]

template<class _CharT , class _Alloc >

_Rope_iterator_base< _CharT, _Alloc >::_Rope_iterator_base ( )

inline

Definition at line 817 of file _rope.h.

817{}

◆ _Rope_iterator_base() [2/3]

template<class _CharT , class _Alloc >

_Rope_iterator_base< _CharT, _Alloc >::_Rope_iterator_base	(	_RopeRep *	__root,
		size_t	__pos
	)

inline

Definition at line 818 of file _rope.h.

819 : _M_current_pos(__pos),_M_root(__root), _M_buf_ptr(0) {}

_Rope_iterator_base::_M_current_pos

size_t _M_current_pos

Definition: _rope.h:764

_Rope_iterator_base::_M_root

_RopeRep * _M_root

Definition: _rope.h:766

_Rope_iterator_base::_M_buf_ptr

_CharT * _M_buf_ptr

Definition: _rope.h:772

◆ _Rope_iterator_base() [3/3]

template<class _CharT , class _Alloc >

_Rope_iterator_base< _CharT, _Alloc >::_Rope_iterator_base ( const _Self & __x )

inline

Definition at line 837 of file _rope.h.

                                        :
      _M_current_pos(__x._M_current_pos),
      _M_root(__x._M_root),
      _M_leaf_pos( __x._M_leaf_pos ),
      _M_buf_start(__x._M_buf_start),
      _M_buf_ptr(__x._M_buf_ptr),
      _M_path_end(__x._M_path_end),
      _M_leaf_index(__x._M_leaf_index),
      _M_path_directions(__x._M_path_directions)
      {
        if (0 != __x._M_buf_ptr) {
          _M_copy_buf(__x);
        }
      }

Member Function Documentation

◆ _M_copy_buf()

template<class _CharT , class _Alloc >

void _Rope_iterator_base< _CharT, _Alloc >::_M_copy_buf ( const _Self & __x )

inlineprivate

Definition at line 825 of file _rope.h.

                                     {
    _M_tmp_buf = __x._M_tmp_buf;
    if (__x._M_buf_start == __x._M_tmp_buf._M_data) {
      _M_buf_start = _M_tmp_buf._M_data;
      _M_buf_end = _M_buf_start + (__x._M_buf_end - __x._M_buf_start);
      _M_buf_ptr = _M_buf_start + (__x._M_buf_ptr - __x._M_buf_start);
    } else {
      _M_buf_end = __x._M_buf_end;
    }
  }

Referenced by _Rope_iterator_base< _CharT, _Alloc >::_Rope_iterator_base(), and _Rope_iterator_base< _CharT, _Alloc >::operator=().

◆ _M_decr()

template<class _CharT , class _Alloc >

void _Rope_iterator_base< _CharT, _Alloc >::_M_decr ( size_t __n )

Definition at line 286 of file _rope.c.

                                                           {
  if (0 != _M_buf_ptr) {
    size_t __chars_left = _M_buf_ptr - _M_buf_start;
    if (__chars_left >= __n) {
      _M_buf_ptr -= __n;
    } else {
      _M_buf_ptr = 0;
    }
  }
  _M_current_pos -= __n;
}

Referenced by _Rope_const_iterator< _CharT, _Alloc >::operator+=(), _Rope_iterator< _CharT, _Alloc >::operator+=(), _Rope_const_iterator< _CharT, _Alloc >::operator--(), _Rope_iterator< _CharT, _Alloc >::operator--(), _Rope_const_iterator< _CharT, _Alloc >::operator-=(), and _Rope_iterator< _CharT, _Alloc >::operator-=().

◆ _M_incr()

template<class _CharT , class _Alloc >

void _Rope_iterator_base< _CharT, _Alloc >::_M_incr ( size_t __n )

Definition at line 270 of file _rope.c.

                                                           {
  _M_current_pos += __n;
  if (0 != _M_buf_ptr) {
    size_t __chars_left = _M_buf_end - _M_buf_ptr;
    if (__chars_left > __n) {
      _M_buf_ptr += __n;
    } else if (__chars_left == __n) {
      _M_buf_ptr += __n;
      _S_setcache_for_incr(*this);
    } else {
      _M_buf_ptr = 0;
    }
  }
}

Referenced by _Rope_const_iterator< _CharT, _Alloc >::operator++(), _Rope_iterator< _CharT, _Alloc >::operator++(), _Rope_const_iterator< _CharT, _Alloc >::operator+=(), _Rope_iterator< _CharT, _Alloc >::operator+=(), _Rope_const_iterator< _CharT, _Alloc >::operator-=(), and _Rope_iterator< _CharT, _Alloc >::operator-=().

◆ _S_setbuf()

template<class _CharT , class _Alloc >

void _Rope_iterator_base< _CharT, _Alloc >::_S_setbuf ( _Rope_iterator_base< _CharT, _Alloc > & __x )

static

Definition at line 90 of file _rope.c.

                                           {
  const _RopeRep* __leaf = __x._M_path_end._M_data[__x._M_leaf_index];
  size_t __leaf_pos = __x._M_leaf_pos;
  size_t __pos = __x._M_current_pos;
 
  switch(__leaf->_M_tag) {
  case _RopeRep::_S_leaf:
    typedef _Rope_RopeLeaf<_CharT, _Alloc> _RopeLeaf;
    __x._M_buf_start = __STATIC_CAST(const _RopeLeaf*, __leaf)->_M_data;
    __x._M_buf_ptr = __x._M_buf_start + (__pos - __leaf_pos);
    __x._M_buf_end = __x._M_buf_start + __leaf->_M_size._M_data;
    break;
  case _RopeRep::_S_function:
  case _RopeRep::_S_substringfn:
    {
      size_t __len = _S_iterator_buf_len;
      size_t __buf_start_pos = __leaf_pos;
      size_t __leaf_end = __leaf_pos + __leaf->_M_size._M_data;
      typedef _Rope_RopeFunction<_CharT, _Alloc> _RopeFunction;
      char_producer<_CharT>* __fn = __STATIC_CAST(const _RopeFunction*, __leaf)->_M_fn;
 
      if (__buf_start_pos + __len <= __pos) {
        __buf_start_pos = __pos - __len/4;
        if (__buf_start_pos + __len > __leaf_end) {
          __buf_start_pos = __leaf_end - __len;
        }
      }
      if (__buf_start_pos + __len > __leaf_end) {
        __len = __leaf_end - __buf_start_pos;
      }
      (*__fn)(__buf_start_pos - __leaf_pos, __len, __x._M_tmp_buf._M_data);
      __x._M_buf_ptr = __x._M_tmp_buf._M_data + (__pos - __buf_start_pos);
      __x._M_buf_start = __x._M_tmp_buf._M_data;
      __x._M_buf_end = __x._M_tmp_buf._M_data + __len;
    }
    break;
  default:
      _STLP_ASSERT(0)
      ;
  }
}

◆ _S_setcache()

template<class _CharT , class _Alloc >

void _Rope_iterator_base< _CharT, _Alloc >::_S_setcache ( _Rope_iterator_base< _CharT, _Alloc > & __x )

static

Definition at line 136 of file _rope.c.

                                           {
  const _RopeRep* __path[_RopeRep::_S_max_rope_depth+1];
  const _RopeRep* __curr_rope;
  int __curr_depth = -1;  /* index into path    */
  size_t __curr_start_pos = 0;
  size_t __pos = __x._M_current_pos;
  unsigned char __dirns = 0; // Bit vector marking right turns in the path
 
  _STLP_ASSERT(__pos <= __x._M_root->_M_size._M_data)
  if (__pos >= __x._M_root->_M_size._M_data) {
    __x._M_buf_ptr = 0;
    return;
  }
  __curr_rope = __x._M_root;
  if (0 != __curr_rope->_M_c_string) {
    /* Treat the root as a leaf. */
    __x._M_buf_start = __curr_rope->_M_c_string;
    __x._M_buf_end = __curr_rope->_M_c_string + __curr_rope->_M_size._M_data;
    __x._M_buf_ptr = __curr_rope->_M_c_string + __pos;
    __x._M_path_end._M_data[0] = __curr_rope;
    __x._M_leaf_index = 0;
    __x._M_leaf_pos = 0;
    return;
  }
  for(;;) {
    ++__curr_depth;
    _STLP_ASSERT(__curr_depth <= _RopeRep::_S_max_rope_depth)
    __path[__curr_depth] = __curr_rope;
    switch(__curr_rope->_M_tag) {
    case _RopeRep::_S_leaf:
    case _RopeRep::_S_function:
    case _RopeRep::_S_substringfn:
      __x._M_leaf_pos = __curr_start_pos;
      goto done;
    case _RopeRep::_S_concat:
      {
        const _RopeConcat* __c = __STATIC_CAST(const _RopeConcat*, __curr_rope);
        _RopeRep* __left = __c->_M_left;
        size_t __left_len = __left->_M_size._M_data;
 
        __dirns <<= 1;
        if (__pos >= __curr_start_pos + __left_len) {
          __dirns |= 1;
          __curr_rope = __c->_M_right;
          __curr_start_pos += __left_len;
        } else {
          __curr_rope = __left;
        }
      }
      break;
    }
  }
done:
    // Copy last section of path into _M_path_end.
  {
    int __i = -1;
    int __j = __curr_depth + 1 - _S_path_cache_len;
 
    if (__j < 0) __j = 0;
    while (__j <= __curr_depth) {
      __x._M_path_end._M_data[++__i] = __path[__j++];
    }
    __x._M_leaf_index = __i;
  }
  __x._M_path_directions = __dirns;
  _S_setbuf(__x);
}

Referenced by _Rope_iterator< _CharT, _Alloc >::_Rope_iterator(), and _Rope_const_iterator< _CharT, _Alloc >::operator*().

◆ _S_setcache_for_incr()

template<class _CharT , class _Alloc >

void _Rope_iterator_base< _CharT, _Alloc >::_S_setcache_for_incr ( _Rope_iterator_base< _CharT, _Alloc > & __x )

static

Definition at line 208 of file _rope.c.

                                         {
  int __current_index = __x._M_leaf_index;
  const _RopeRep* __current_node = __x._M_path_end._M_data[__current_index];
  size_t __len = __current_node->_M_size._M_data;
  size_t __node_start_pos = __x._M_leaf_pos;
  unsigned char __dirns = __x._M_path_directions;
  const _RopeConcat* __c;
 
  _STLP_ASSERT(__x._M_current_pos <= __x._M_root->_M_size._M_data)
  if (__x._M_current_pos - __node_start_pos < __len) {
    /* More stuff in this leaf, we just didn't cache it. */
    _S_setbuf(__x);
    return;
  }
  _STLP_ASSERT(__node_start_pos + __len == __x._M_current_pos)
    //  node_start_pos is starting position of last_node.
  while (--__current_index >= 0) {
    if (!(__dirns & 1) /* Path turned left */)
      break;
    __current_node = __x._M_path_end._M_data[__current_index];
    __c = __STATIC_CAST(const _RopeConcat*, __current_node);
    // Otherwise we were in the right child.  Thus we should pop
    // the concatenation node.
    __node_start_pos -= __c->_M_left->_M_size._M_data;
    __dirns >>= 1;
  }
  if (__current_index < 0) {
    // We underflowed the cache. Punt.
    _S_setcache(__x);
    return;
  }
  __current_node = __x._M_path_end._M_data[__current_index];
  __c = __STATIC_CAST(const _RopeConcat*, __current_node);
  // current_node is a concatenation node.  We are positioned on the first
  // character in its right child.
  // node_start_pos is starting position of current_node.
  __node_start_pos += __c->_M_left->_M_size._M_data;
  __current_node = __c->_M_right;
  __x._M_path_end._M_data[++__current_index] = __current_node;
  __dirns |= 1;
  while (_RopeRep::_S_concat == __current_node->_M_tag) {
    ++__current_index;
    if (_S_path_cache_len == __current_index) {
      int __i;
      for (__i = 0; __i < _S_path_cache_len-1; ++__i) {
        __x._M_path_end._M_data[__i] = __x._M_path_end._M_data[__i+1];
      }
      --__current_index;
    }
    __current_node = __STATIC_CAST(const _RopeConcat*, __current_node)->_M_left;
    __x._M_path_end._M_data[__current_index] = __current_node;
    __dirns <<= 1;
    // node_start_pos is unchanged.
  }
  __x._M_leaf_index = __current_index;
  __x._M_leaf_pos = __node_start_pos;
  __x._M_path_directions = __dirns;
  _S_setbuf(__x);
}

◆ index()

template<class _CharT , class _Alloc >

size_t _Rope_iterator_base< _CharT, _Alloc >::index ( ) const

inline

Definition at line 823 of file _rope.h.

823{ return _M_current_pos; }

Referenced by _Rope_rotate(), rope< _CharT, _Alloc >::erase(), rope< _CharT, _Alloc >::find(), rope< _CharT, _Alloc >::insert(), rope< _CharT, _Alloc >::replace(), and rope< _CharT, _Alloc >::substr().

◆ operator=()

template<class _CharT , class _Alloc >

_Self & _Rope_iterator_base< _CharT, _Alloc >::operator= ( const _Self & __x )

inline

Definition at line 851 of file _rope.h.

      {
        _M_current_pos = __x._M_current_pos;
        _M_root = __x._M_root;
        _M_buf_start = __x._M_buf_start;
        _M_buf_ptr = __x._M_buf_ptr;
        _M_path_end = __x._M_path_end;
        _M_leaf_index = __x._M_leaf_index;
        _M_path_directions = __x._M_path_directions;
        _M_leaf_pos = __x._M_leaf_pos;
        if (0 != __x._M_buf_ptr) {
          _M_copy_buf(__x);
        }
        return *this;
      }