MNRopeIteratorBase.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_BASE_H
#define _R_ITERATOR_BASE_H

#include <sys/types.h>

// Rope iterators:
// Unlike in the C version, we cache only part of the stack
// for rope iterators, since they must be efficiently copyable.
// When we run out of cache, we have to reconstruct the iterator
// value.
// Pointers from iterators are not included in reference counts.
// Iterators are assumed to be thread private.  Ropes can
// be shared.

class MNRopeRep;

class MNRopeIteratorBase
{
    friend class MNRope;

protected:
    enum { _S_path_cache_len = 4 }; // Must be <= 9.

    enum { _S_iterator_buf_len = 15 };

    size_t          _M_current_pos;

    MNRopeRep*       _M_root;
                        // The whole rope.

    size_t          _M_leaf_pos;
                        // Starting position for current leaf
    uchar_t*          _M_buf_start;
                        // Buffer possibly
                        // containing current char.
    uchar_t*          _M_buf_ptr;
                        // Pointer to current char in buffer.
                        // != 0 ==> buffer valid.
    uchar_t*          _M_buf_end;
                        // One past __last valid char in buffer.

    // What follows is the path cache.  We go out of our
    // way to make this compact.
    // Path_end contains the bottom section of the path from
    // the root to the current leaf.
    const MNRopeRep* _M_path_end[_S_path_cache_len];

    int             _M_leaf_index;
                        // Last valid __pos in path_end;
                        // _M_path_end[0] ... _M_path_end[leaf_index-1]
                        // point to concatenation nodes.
    unsigned char   _M_path_directions;
                        // (path_directions >> __i) & 1 is 1
                        // iff we got from _M_path_end[leaf_index - __i - 1]
                        // to _M_path_end[leaf_index - __i] by going to the
                        // __right. Assumes path_cache_len <= 9.
    uchar_t           _M_tmp_buf[_S_iterator_buf_len];
                        // Short buffer for surrounding chars.
                        // This is useful primarily for 
                        // RopeFunctions.  We put the buffer
                        // here to avoid locking in the
                        // multithreaded case.

    // The cached path is generally assumed to be valid
    // only if the buffer is valid.
    static void _S_setbuf(MNRopeIteratorBase& __x);
                                        // Set buffer contents given
                                        // path cache.
    static void _S_setcache(MNRopeIteratorBase& __x);
                                        // Set buffer contents and
                                        // path cache.
    static void _S_setcache_for_incr(MNRopeIteratorBase& __x);
                                        // As above, but assumes path
                                        // cache is valid for previous posn.
    MNRopeIteratorBase();
    MNRopeIteratorBase(MNRopeRep* __root, size_t __pos);

    void _M_incr(size_t __n);

    void _M_decr(size_t __n);

public:
    size_t index() const;

    MNRopeIteratorBase(const MNRopeIteratorBase& __x);
};


#endif /* _R_ITERATOR_BASE_H */

---