CircularIteratorImpl.h

Go to the documentation of this file.

#pragma once
/*
 *  This file is part of the gobelijn software.
 *  Gobelijn is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation, either version 3 of the License, or any later
 *  version. Gobelijn 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 General Public License for details. You should have received
 *  a copy of the GNU General Public License along with the software. If not,
 *  see <http://www.gnu.org/licenses/>.
 *
 *  Copyright 2012, Jan Broeckhove, CoMP research group, Universiteit Antwerpen.
 */
#include <iterator>

namespace UA_CoMP {
namespace Container {

namespace Impl_ {
template <typename T, typename V, typename P = V*, typename R = V&>
class CircularIterator : public std::iterator<std::bidirectional_iterator_tag, V, typename T::difference_type, P, R>
{
public:
        // ==================================================================
        // Member types (in addition to those introduced by the std::iterator
        // base class (i.e. value_type, difference_type, pointer, reference,
        // iterator_category).
        // ==================================================================
        using type = CircularIterator<T, V, P, R>;
        using base_type = T;

        CircularIterator(base_type b, base_type e, base_type i) : m_begin(b), m_end(e), m_it(i) {}

        base_type get() const { return m_it; }

        explicit operator base_type() const { return m_it; }

        type& operator=(const base_type& i)
        {
                m_it = i;
                return *this;
        }

        typename type::reference operator*() const { return (*m_it); }

        typename type::pointer operator->() const { return &(operator*()); }

        type& operator++()
        {
                ++m_it;
                if (m_it == m_end) {
                        m_it = m_begin;
                }
                return (*this);
        }

        type operator++(int)
        {
                type t(*this);
                ++(*this);
                return t;
        }

        type& operator--()
        {
                if (m_it == m_begin) {
                        m_it = m_end;
                }
                --m_it;
                return (*this);
        }

        type operator--(int)
        {
                type t(*this);
                --(*this);
                return t;
        }

        bool operator==(const type& rhs) const { return (m_it == rhs.m_it); }

        bool operator==(const base_type& rhs) const { return (m_it == rhs); }

        bool operator!=(const type& rhs) const { return !operator==(rhs); }

        bool operator!=(const base_type& rhs) const { return !operator==(rhs); }

protected:
        base_type m_begin;
        base_type m_end;
        base_type m_it;
};
} // namespace Impl_
} // namespace Container
} // namespace UA_CoMP