MNRopeIterator.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_ITERATOR_H
#define _R_ITERATOR_H

#include <stddef.h>

#include "MNRopeIteratorBase.h"
#include "MNRopeRep.h"
#include "MNRefProxy.h"

class MNRope;

inline void pft( MNRopeIteratorBase& dest, const MNRopeIteratorBase& src )
{
    dest = src;
}

class MNRopeIterator
    : public MNRopeIteratorBase
{
    friend class MNRope;

protected:
    MNRope* _M_root_rope;

        // root is treated as a cached version of this,
        // and is used to detect changes to the underlying
        // rope.
        // Root is included in the reference count.
        // This is necessary so that we can detect changes reliably.
        // Unfortunately, it requires careful bookkeeping for the
        // nonGC case.
    MNRopeIterator(MNRope* __r, size_t __pos);

    void _M_check();

public:
    typedef MNRefProxy  reference;
    typedef MNRefProxy* pointer;

public:
    MNRope& container()
    {
        return *_M_root_rope;
    }

    MNRopeIterator()
    {
        _M_root = 0;  // Needed for reference counting.
    };

    MNRopeIterator(const MNRopeIterator& __x)
        : MNRopeIteratorBase(__x)
    {
        _M_root_rope = __x._M_root_rope;
        MNRopeRep::_S_ref(_M_root);
    }

    MNRopeIterator(MNRope& __r, size_t __pos);

    ~MNRopeIterator()
    {
        MNRopeRep::_S_unref(_M_root);
    }

    MNRopeIterator& operator= (const MNRopeIterator& __x)
    {
        MNRopeRep* __old = _M_root;

        MNRopeRep::_S_ref(__x._M_root);
        if (0 != __x._M_buf_ptr) {
            _M_root_rope = __x._M_root_rope;
            // *(static_cast<MNRopeIteratorBase*>(this)) = __x;
            // xlC 3.1.4 is too old for true ANSI
            pft(*this,__x);
        } else {
            _M_current_pos = __x._M_current_pos;
            _M_root = __x._M_root;
            _M_root_rope = __x._M_root_rope;
            _M_buf_ptr = 0;
        }
        MNRopeRep::_S_unref(__old);
        return(*this);
    }

    reference operator*()
    {
        _M_check();
        if (0 == _M_buf_ptr) {
            return MNRefProxy(
               _M_root_rope, _M_current_pos);
        } else {
            return MNRefProxy(
               _M_root_rope, _M_current_pos, *_M_buf_ptr);
        }
    }
    MNRopeIterator& operator++() {
        _M_incr(1);
        return *this;
    }

    MNRopeIterator& operator+=(ptrdiff_t __n)
    {
        if (__n >= 0) {
            _M_incr(__n);
        } else {
            _M_decr(-__n);
        }
        return *this;
    }

    MNRopeIterator& operator--()
    {
        _M_decr(1);
        return *this;
    }

    MNRopeIterator& operator-=(ptrdiff_t __n)
    {
        if (__n >= 0) {
            _M_decr(__n);
        } else {
            _M_incr(-__n);
        }
        return *this;
    }

    MNRopeIterator operator++(int)
    {
        size_t __old_pos = _M_current_pos;
        _M_incr(1);
        return MNRopeIterator(_M_root_rope, __old_pos);
    }

    MNRopeIterator operator--(int)
    {
        size_t __old_pos = _M_current_pos;
        _M_decr(1);
        return MNRopeIterator(_M_root_rope, __old_pos);
    }

    reference operator[](ptrdiff_t __n)
    {
        return MNRefProxy(
          _M_root_rope, _M_current_pos + __n);
    }

    friend bool operator==
        (const MNRopeIterator& __x,
         const MNRopeIterator& __y);

    friend bool operator<
        (const MNRopeIterator& __x,
         const MNRopeIterator& __y);

    friend ptrdiff_t operator-
        (const MNRopeIterator& __x,
         const MNRopeIterator& __y);

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

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

    friend MNRopeIterator operator+
        (ptrdiff_t __n, const MNRopeIterator& __x);
};

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

bool operator== (const MNRopeIterator& __x, const MNRopeIterator& __y);
bool operator<  (const MNRopeIterator& __x, const MNRopeIterator& __y);
ptrdiff_t operator- (const MNRopeIterator& __x, const MNRopeIterator& __y);

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

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

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

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

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

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

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

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

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

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


#endif /* _R_ITERATOR_H */

---