indirect_range_iterator.h

Go to the documentation of this file.

#pragma once

namespace illumina { namespace interop { namespace util
{
    class abstract_range_iterator
    {
    public:
        virtual ~abstract_range_iterator(){}
        abstract_range_iterator& operator++()
        {
            advance();
            return *this;
        }
        void operator()()
        {
            reset();
        }
        operator bool() const
        {
            return !is_done();
        }

    public:
        virtual void reset()=0;
        virtual void advance()=0;
        virtual bool is_done()const=0;
    };

    class chain_range_iterator : public abstract_range_iterator
    {
    public:
        chain_range_iterator(abstract_range_iterator* it1=0, abstract_range_iterator* it2=0) :
                m_iterator_1(it1), m_iterator_2(it2)
        {
        }
        template<int N>
        chain_range_iterator(abstract_range_iterator* (&iterators)[N], size_t current=0, size_t dummy=0)
        {
            (void)dummy;
            m_iterator_1 = iterators[current];
            if( (current+2) < N )
                m_iterator_2 = new chain_range_iterator(iterators, current+1, 0);
            else m_iterator_2 = iterators[current+1];
        }
        virtual ~chain_range_iterator()
        {
            delete m_iterator_1;
            delete m_iterator_2;
        }

    public:
        chain_range_iterator(const chain_range_iterator& other) :
                abstract_range_iterator(), m_iterator_1(other.m_iterator_1), m_iterator_2(other.m_iterator_2)
        {
            other.m_iterator_1 = 0;
            other.m_iterator_2 = 0;
        }
        chain_range_iterator& operator=(const chain_range_iterator& other)
        {
            delete m_iterator_1;
            delete m_iterator_2;
            m_iterator_1 = other.m_iterator_1;
            m_iterator_2 = other.m_iterator_2;
            other.m_iterator_1 = 0;
            other.m_iterator_2 = 0;
            return *this;
        }

    public:
        void reset()
        {
            INTEROP_ASSERT(m_iterator_1 != 0);
            INTEROP_ASSERT(m_iterator_2 != 0);
            if(m_iterator_2 == 0 || m_iterator_1 == 0) return;
            m_iterator_1->reset();
            m_iterator_2->reset();
        }
        void advance()
        {
            INTEROP_ASSERT(m_iterator_1 != 0);
            INTEROP_ASSERT(m_iterator_2 != 0);
            if(m_iterator_2 == 0 || m_iterator_1 == 0) return;
            m_iterator_1->advance();
            if(m_iterator_1->is_done())
            {

                m_iterator_2->advance();
                if(!m_iterator_2->is_done()) m_iterator_1->reset();
            }
        }
        bool is_done()const
        {
            INTEROP_ASSERT(m_iterator_2 != 0);
            if(m_iterator_2 == 0 || m_iterator_1 == 0) return true;
            return m_iterator_1->is_done() && m_iterator_2->is_done();
        }

    private:
        mutable abstract_range_iterator* m_iterator_1;
        mutable abstract_range_iterator* m_iterator_2;
    };
    template<typename T, typename Storage=T>
    class indirect_range_iterator : public abstract_range_iterator
    {
    public:
        indirect_range_iterator(T &rval) : m_value(&rval),
                                           m_begin(static_cast<Storage>(rval)),
                                           m_end(static_cast<Storage>(rval))
        {
            reset();
        }
        indirect_range_iterator(T &rval, const T beg, const T end, const bool reset_state=true) : m_value(&rval),
                                                                     m_begin(static_cast<Storage>(beg)),
                                                                     m_end(static_cast<Storage>(end))
        {
            if(reset_state) reset();
        }
        virtual ~indirect_range_iterator(){}

    public:
        void reset()
        {
            (*m_value) = static_cast<T>(m_begin);
        }
        void advance()
        {
            const Storage sval = static_cast<Storage>(*m_value)+1;
            (*m_value) = static_cast<T>(sval);
        }

        bool is_done() const
        {
            return (*m_value) >= static_cast<T>(m_end);
        }

    private:
        T* m_value;
        Storage m_begin;
        Storage m_end;
    };

}}}