vstringiterator.h

Go to the documentation of this file.

/*
Copyright c1997-2014 Trygve Isaacson. All rights reserved.
This file is part of the Code Vault version 4.1
http://www.bombaydigital.com/
License: MIT. See LICENSE.md in the Vault top level directory.
*/

#ifndef vstringiterator_h
#define vstringiterator_h

#include "vtypes.h"

#include "vcodepoint.h"

class VString;

// External linkage so that this header isn't dependent upon vexception.h.
extern void VStringIteratorThrowOutOfBoundsBegin();
extern void VStringIteratorThrowOutOfBoundsEnd();

template<typename vstring_ref> // vstring_ref may be 'const VString&' or 'VString&'
class VStringIterator {

    public:
        VStringIterator(const VStringIterator& iter)
            : mSource(iter.mSource)
            , mIsForwardIterator(iter.mIsForwardIterator)
            , mCurrentCodePointOffset(iter.mCurrentCodePointOffset)
            , mSourceLength(iter.mSourceLength)
            {
        }

        VStringIterator(vstring_ref source, bool isForwardIterator, bool goToEnd=false)
            : mSource(source)
            , mIsForwardIterator(isForwardIterator)
            , mCurrentCodePointOffset(0)
            , mSourceLength(source.length())
            {
            // If going to end on forward iterator, or not going to end on reverse iterator, then seek to end of our data.
            if (goToEnd == isForwardIterator) {
                this->_seekToEnd();
            }
        }

        ~VStringIterator() {}

        VStringIterator& operator=(const VStringIterator& iter) {
            if (this != &iter) {
                mSource = iter.mSource;
                mIsForwardIterator = iter.mIsForwardIterator;
                mCurrentCodePointOffset = iter.mCurrentCodePointOffset;
                mSourceLength = iter.mSourceLength;
            }
            
            return *this;
        }
        
        VCodePoint operator*() const {
            if (mIsForwardIterator) {
                return VCodePoint(mSource.getDataBufferConst(), mCurrentCodePointOffset);
            } else {
                int previousCodePointOffset = VCodePoint::getPreviousUTF8CodePointOffset(mSource.getDataBufferConst(), mCurrentCodePointOffset);
                return VCodePoint(mSource.getDataBufferConst(), previousCodePointOffset);
            }
        }

        VStringIterator operator+(int n) const {
            VStringIterator i(*this);
            i += n;
            return i;
        }
        
        VStringIterator operator-(int n) const {
            VStringIterator i(*this);
            i -= n;
            return i;
        }
        
        VStringIterator& operator+=(int n) {
            this->_increment(n);
            return *this;
        }

        VStringIterator& operator-=(int n) {
            this->_decrement(n);
            return *this;
        }

        VStringIterator& operator++() {
            this->_increment(1);
            return *this;
        }

        VStringIterator& operator--() {
            this->_decrement(1);
            return *this;
        }
        
        int getCurrentOffset() const {
            return mCurrentCodePointOffset;
        }
        
        friend inline bool operator==(const VStringIterator<vstring_ref>& i1, const VStringIterator<vstring_ref>& i2) {
            return (i1.mSource == i2.mSource) && (i1.mCurrentCodePointOffset == i2.mCurrentCodePointOffset);
        }

        friend inline bool operator!=(const VStringIterator<vstring_ref>& i1, const VStringIterator<vstring_ref>& i2) {
            return !operator==(i1, i2);
        }
    
    private:
    
        void _seekToEnd() {
            mCurrentCodePointOffset = mSourceLength;
        }

        void _increment(int n) {
            if (mIsForwardIterator) {
                this->_moveOffsetForwardInBuffer(n);
            } else {
                this->_moveOffsetBackwardInBuffer(n);
            }
        }

        void _decrement(int n) {
            if (mIsForwardIterator) {
                this->_moveOffsetBackwardInBuffer(n);
            } else {
                this->_moveOffsetForwardInBuffer(n);
            }
        }
    
        void _moveOffsetForwardInBuffer(int n) {
            // If we are at offset -1 (typical for "end" of reverse iterator), there is no valid buffer to examine at [-1],
            // so we just move forward to the first byte, at [0]. After that, normal examine-code-point-and-see-how-big-it-is
            // incrementing works.
            if ((mCurrentCodePointOffset == -1) && (n > 0)) {
                mCurrentCodePointOffset = 0;
                --n;
            }

            for (int i = 0; i < n; ++i) {
                if (mCurrentCodePointOffset == mSourceLength) {
                    VStringIteratorThrowOutOfBoundsEnd();
                }

                VCodePoint cp(mSource.getDataBufferConst(), mCurrentCodePointOffset);
                mCurrentCodePointOffset += cp.getUTF8Length();
            }
        }
        
        void _moveOffsetBackwardInBuffer(int n) {
            // If we are at [0], we just move backwards to [-1], and we never move beyond that. (Iterating off the end of
            // a container is undefined behavior. At least)
            const Vu8* bufferPtr = mSource.getDataBufferConst() + mCurrentCodePointOffset;
            for (int i = 0; i < n; ++i) {
            
                do {
                    if (mCurrentCodePointOffset == 0) {
                        VStringIteratorThrowOutOfBoundsBegin();
                    }

                    --bufferPtr;
                    --mCurrentCodePointOffset;
                } while (VCodePoint::isUTF8ContinuationByte(*bufferPtr)); 

            }
        }
    
        vstring_ref mSource;                    
        bool        mIsForwardIterator;         
        int         mCurrentCodePointOffset;    
        int         mSourceLength;              
};

#endif /* vstringiterator_h */