MNRopeConstIterator.h

Go to the documentation of this file.

/*
 * Copyright (c) 1997
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided "as is" without express or implied warranty.
 *
 * Heavily modified by KOM/Darmstadt University of Technology, 2000
 */
#ifndef _R_CONST_ITERATOR_H
#define _R_CONST_ITERATOR_H

#include "MNRopeIterator.h"

class MNRopeConstIterator : public MNRopeIteratorBase
{
    friend class MNRope;
protected:
    MNRopeConstIterator(const MNRopeRep* __root, size_t __pos);
public:
    typedef uchar_t reference;    // Really a value.  Returning a reference
                                // Would be a mess, since it would have
                                // to be included in refcount.
    typedef const uchar_t* pointer;

public:
    MNRopeConstIterator();
    MNRopeConstIterator(const MNRopeConstIterator& __x);
    MNRopeConstIterator(const MNRopeIterator& __x);
    MNRopeConstIterator(const MNRope& __r, size_t __pos);

    MNRopeConstIterator& operator= (const MNRopeConstIterator& __x);

    reference operator*() {
        if (0 == _M_buf_ptr) _S_setcache(*this);
        return *_M_buf_ptr;
    }
    MNRopeConstIterator& operator++() {
         uchar_t* __next;
        if (0 != _M_buf_ptr && (__next = _M_buf_ptr + 1) < _M_buf_end) {
            _M_buf_ptr = __next;
            ++_M_current_pos;
        } else {
            _M_incr(1);
        }
        return *this;
    }
    MNRopeConstIterator& operator+=(ptrdiff_t __n) {
        if (__n >= 0) {
            _M_incr(__n);
        } else {
            _M_decr(-__n);
        }
        return *this;
    }
    MNRopeConstIterator& operator--() {
        _M_decr(1);
        return *this;
    }
    MNRopeConstIterator& operator-=(ptrdiff_t __n) {
        if (__n >= 0) {
            _M_decr(__n);
        } else {
            _M_incr(-__n);
        }
        return *this;
    }
    MNRopeConstIterator operator++(int) {
        size_t __old_pos = _M_current_pos;
        _M_incr(1);
        return MNRopeConstIterator(_M_root, __old_pos);
        // This makes a subsequent dereference expensive.
        // Perhaps we should instead copy the iterator
        // if it has a valid cache?
    }
    MNRopeConstIterator operator--(int) {
        size_t __old_pos = _M_current_pos;
        _M_decr(1);
        return MNRopeConstIterator(_M_root, __old_pos);
    }

    friend MNRopeConstIterator operator-
        (const MNRopeConstIterator& __x,
         ptrdiff_t __n);
    friend MNRopeConstIterator operator+
        (const MNRopeConstIterator& __x,
         ptrdiff_t __n);
    friend MNRopeConstIterator operator+
        (ptrdiff_t __n,
         const MNRopeConstIterator& __x);

    reference operator[](size_t __n);

    friend bool operator==
        (const MNRopeConstIterator& __x,
         const MNRopeConstIterator& __y);
    friend bool operator< 
        (const MNRopeConstIterator& __x,
         const MNRopeConstIterator& __y);
    friend ptrdiff_t operator-
        (const MNRopeConstIterator& __x,
         const MNRopeConstIterator& __y);
};

MNRopeConstIterator operator-(const MNRopeConstIterator& __x, ptrdiff_t __n);

MNRopeConstIterator operator+(const MNRopeConstIterator& __x, ptrdiff_t __n);

MNRopeConstIterator operator+(ptrdiff_t __n, const MNRopeConstIterator& __x);

bool operator== (const MNRopeConstIterator& __x,
                 const MNRopeConstIterator& __y);

bool operator< (const MNRopeConstIterator& __x,
                 const MNRopeConstIterator& __y);

ptrdiff_t operator- (const MNRopeConstIterator& __x,
                     const MNRopeConstIterator& __y);

inline bool operator== (const MNRopeConstIterator& __x,
                        const MNRopeConstIterator& __y)
{
  return (__x._M_current_pos == __y._M_current_pos && 
          __x._M_root == __y._M_root);
}

inline bool operator< (const MNRopeConstIterator& __x,
                       const MNRopeConstIterator& __y)
{
  return (__x._M_current_pos < __y._M_current_pos);
}

inline bool operator!= (const MNRopeConstIterator& __x,
                        const MNRopeConstIterator& __y)
{
  return !(__x == __y);
}

inline bool operator> (const MNRopeConstIterator& __x,
                       const MNRopeConstIterator& __y)
{
  return __y < __x;
}

inline bool operator<= (const MNRopeConstIterator& __x,
                        const MNRopeConstIterator& __y)
{
  return !(__y < __x);
}

inline bool operator>= (const MNRopeConstIterator& __x,
                        const MNRopeConstIterator& __y)
{
  return !(__x < __y);
}

inline ptrdiff_t operator-(const MNRopeConstIterator& __x,
                           const MNRopeConstIterator& __y)
{
  return (ptrdiff_t)__x._M_current_pos - (ptrdiff_t)__y._M_current_pos;
}

inline MNRopeConstIterator
operator-(const MNRopeConstIterator& __x, ptrdiff_t __n)
{
  return MNRopeConstIterator(
            __x._M_root, __x._M_current_pos - __n);
}

inline MNRopeConstIterator
operator+(const MNRopeConstIterator& __x, ptrdiff_t __n)
{
  return MNRopeConstIterator(
           __x._M_root, __x._M_current_pos + __n);
}

inline MNRopeConstIterator
operator+(ptrdiff_t __n, const MNRopeConstIterator& __x)
{
  return MNRopeConstIterator(
           __x._M_root, __x._M_current_pos + __n);
}

inline MNRopeConstIterator find( MNRopeConstIterator __first,
                                  MNRopeConstIterator __last,
                                  uchar_t                __val )
{
    while (__first != __last && *__first != __val)
      ++__first;
    return __first;
}

inline MNRopeConstIterator search( MNRopeConstIterator __first1,
                                    MNRopeConstIterator __last1,
                                    const uchar_t*         __first2,
                                    const uchar_t*         __last2 )
{
  // Test for empty ranges
  if (__first1 == __last1 || __first2 == __last2)
    return __first1;

  // Test for a pattern of length 1.
  const uchar_t* __tmp(__first2);
  ++__tmp;
  if (__tmp == __last2)
    return find(__first1, __last1, *__first2);

  // General case.

  const uchar_t* __p1;
  const uchar_t* __p;

  __p1 = __first2; ++__p1;

  MNRopeConstIterator __current = __first1;

  while (__first1 != __last1) {
    __first1 = find(__first1, __last1, *__first2);
    if (__first1 == __last1)
      return __last1;

    __p = __p1;
    __current = __first1;
    if (++__current == __last1)
      return __last1;

    while (*__current == *__p) {
      if (++__p == __last2)
        return __first1;
      if (++__current == __last1)
        return __last1;
    }

    ++__first1;
  }
  return __first1;
}

namespace Rope
{

inline
int lexicographical_compare_3way( const uchar_t* __first1,
                                         const uchar_t* __last1,
                                         const uchar_t* __first2,
                                         const uchar_t* __last2 )
{
    const ptrdiff_t __len1 = __last1 - __first1;
    const ptrdiff_t __len2 = __last2 - __first2;
    const int __result = memcmp(__first1, __first2, min(__len1, __len2));
    return __result != 0 ? __result
                         : (__len1 == __len2 ? 0 : (__len1 < __len2 ? -1 : 1));
}

inline
int lexicographical_compare_3way( const uchar_t* __first1,
                                  const uchar_t* __last1,
                                  MNRopeConstIterator __first2,
                                  MNRopeConstIterator __last2 )
{
  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first1 < *__first2)
      return -1;
    if (*__first2 < *__first1)
      return 1;
    ++__first1;
    ++__first2;
  }
  if (__first2 == __last2) {
    return !(__first1 == __last1);
  }
  else {
    return -1;
  }
}

inline
int lexicographical_compare_3way( MNRopeConstIterator __first1,
                                  MNRopeConstIterator __last1,
                                  const uchar_t* __first2,
                                  const uchar_t* __last2 )
{
  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first1 < *__first2)
      return -1;
    if (*__first2 < *__first1)
      return 1;
    ++__first1;
    ++__first2;
  }
  if (__first2 == __last2) {
    return !(__first1 == __last1);
  }
  else {
    return -1;
  }
}

inline
int lexicographical_compare_3way( MNRopeConstIterator __first1,
                                  MNRopeConstIterator __last1,
                                  MNRopeConstIterator __first2,
                                  MNRopeConstIterator __last2 )
{
  while (__first1 != __last1 && __first2 != __last2) {
    if (*__first1 < *__first2)
      return -1;
    if (*__first2 < *__first1)
      return 1;
    ++__first1;
    ++__first2;
  }
  if (__first2 == __last2) {
    return !(__first1 == __last1);
  }
  else {
    return -1;
  }
}

}; // namespace Rope


#endif /* _R_CONST_ITERATOR_H */

---