Common/Util/Circulator.h

Go to the documentation of this file.

//-------------------------------------------------------------------
//  Copyright (c) 2004 Evan Sherbrooke
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
//
//-------------------------------------------------------------------

#ifndef VOLUMILL_CIRCULATOR_H
#define VOLUMILL_CIRCULATOR_H

#pragma once

#include <boost/iterator/iterator_facade.hpp>
#include <boost/type_traits.hpp>

namespace util
{

template<class Iterator>
class Circulator : public boost::iterator_facade<
        Circulator<Iterator>,
        typename std::iterator_traits<Iterator>::value_type,
        boost::bidirectional_traversal_tag,
        typename std::iterator_traits<Iterator>::reference
>
{
public:
        Circulator() {}
        explicit Circulator(Iterator begin, Iterator end, Iterator pos)
                : m_begin (begin), m_end (end), m_pos (pos) {}

        Iterator getIterator() const { return m_pos; }

        // For compatibility with other circulator types
        bool isValid() const { return m_begin != m_end; }
private:
        friend class boost::iterator_core_access;
        // should this compare ranges too? It seems inefficient and unnecessary
        bool equal(Circulator<Iterator> const& other) const
        {
                return this->m_pos == other.m_pos;
        }
   void increment()
        {
                ++m_pos;
                if (m_pos == m_end)
                        m_pos = m_begin;
        }
        void decrement()
        {
                if (m_pos == m_begin)
                        m_pos = m_end;
                --m_pos;
        }
        typename std::iterator_traits<Iterator>::reference dereference() const
        {
                return *m_pos;
        }
   Iterator m_begin, m_end, m_pos;
};

template<class Iterator>
inline Circulator<Iterator> makeCirculator (Iterator begin, Iterator end, Iterator pos)
{
        return Circulator<Iterator> (begin, end, pos);
}

template<class Circulator>
class CirculatorToIterator : public boost::iterator_facade<
        CirculatorToIterator<Circulator>,
        typename std::iterator_traits<Circulator>::value_type,
        boost::bidirectional_traversal_tag,
        typename std::iterator_traits<Circulator>::reference
>
{
public:
        CirculatorToIterator() {}
        explicit CirculatorToIterator(Circulator c, int winding = 0)
                : m_circ (c), m_start (c), m_winding (winding) {}

        Circulator getCirculator() const { return m_circ; }
private:
        friend class boost::iterator_core_access;
        bool equal(CirculatorToIterator<Circulator> const& other) const
        {
                return this->m_circ == other.m_circ && this->m_winding == other.m_winding;
        }
   void increment()
        {
                ++m_circ;
                if (m_circ == m_start)
                        ++m_winding;
        }
        void decrement()
        {
                if (m_circ == m_start)
                        --m_winding;
                --m_circ;
        }
        typename std::iterator_traits<Circulator>::reference dereference() const
        {
                return *m_circ;
        }
   Circulator m_circ, m_start;
        int m_winding;
};

template<class Circulator>
inline CirculatorToIterator<Circulator> makeBeginIteratorFromCirculator (Circulator circ)
{
        return CirculatorToIterator<Circulator> (circ);
}

template<class Circulator>
inline CirculatorToIterator<Circulator> makeEndIteratorFromCirculator (Circulator circ)
{
        return CirculatorToIterator<Circulator> (circ, circ.isValid() ? 1 : 0);
}

}
#endif

---