CircularIteratorImpl.h

Go to the documentation of this file.

#ifndef CONTAINER_CIRCULAR_ITERATOR_IMPL_H_
#define CONTAINER_CIRCULAR_ITERATOR_IMPL_H_
/*
 * Copyright 2011-2016 Universiteit Antwerpen
 *
 * Licensed under the EUPL, Version 1.1 or  as soon they will be approved by
 * the European Commission - subsequent versions of the EUPL (the "Licence");
 * You may not use this work except in compliance with the Licence.
 * You may obtain a copy of the Licence at: http://ec.europa.eu/idabc/eupl5
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the Licence is distributed on an "AS IS" basis,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Licence for the specific language governing
 * permissions and limitations under the Licence.
 */
#include <iterator>

namespace SimPT_Sim {
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
} // namespace
} // namespace

#endif // end-of-include-guard