sourceiterator.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2014 Patrick P. Frey
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */

#ifndef __TEXTWOLF_SOURCE_ITERATOR_HPP__
#define __TEXTWOLF_SOURCE_ITERATOR_HPP__
#include "textwolf/exception.hpp"
#include "textwolf/position.hpp"
#include <cstdlib>
#include <stdexcept>
#include <setjmp.h>

namespace textwolf {

class SrcIterator
        :public throws_exception 
{
public:
        SrcIterator()
                :m_start(0)
                ,m_itr(0)
                ,m_end(0)
                ,m_eom(0)
                ,m_abspos(0){}

        SrcIterator( const SrcIterator& o)
                :m_start(o.m_start)
                ,m_itr(o.m_itr)
                ,m_end(o.m_end)
                ,m_eom(o.m_eom)
                ,m_abspos(o.m_abspos){}

        SrcIterator( const char* buf, std::size_t size, jmp_buf* eom_=0)
                :m_start(const_cast<char*>(buf))
                ,m_itr(const_cast<char*>(buf))
                ,m_end(m_itr+size)
                ,m_eom(eom_)
                ,m_abspos(0){}

        SrcIterator& operator=( const SrcIterator& o)
        {
                m_start = o.m_start;
                m_itr = o.m_itr;
                m_end = o.m_end;
                m_eom = o.m_eom;
                m_abspos = o.m_abspos;
                return *this;
        }

        inline char operator*()
        {
                if (m_itr >= m_end)
                {
                        if (m_eom) longjmp(*m_eom,1);
                        return 0;
                }
                return *m_itr;
        }

        inline SrcIterator& operator++()
        {
                ++m_itr;
                return *this;
        }

        inline std::size_t operator-( const SrcIterator& b) const
        {
                if (b.m_end != m_end || m_itr < b.m_itr) throw exception( IllegalParam);
                return m_itr - b.m_itr;
        }

        void putInput( const char* buf, std::size_t size, jmp_buf* eom=0)
        {
                m_abspos += size;
                m_start = m_itr = const_cast<char*>(buf);
                m_end = m_itr+size;
                m_eom = eom;
        }

        std::size_t getPosition() const
        {
                return (m_end >= m_itr)?(m_itr-m_start):0;
        }

        PositionIndex position() const
        {
                return m_abspos - (m_end - m_itr);
        }

        bool endOfChunk() const
        {
                return (m_itr >= m_end);
        }

private:
        char* m_start;
        char* m_itr;
        char* m_end;
        jmp_buf* m_eom;
        PositionIndex m_abspos;
};

}//namespace
#endif