SVIterator.h

Go to the documentation of this file.

#ifndef CONTAINER_S_V_ITERATOR_H_
#define CONTAINER_S_V_ITERATOR_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 <cassert>
#include <cstddef>
#include <iterator>
#include <limits>
#include <type_traits>

namespace SimPT_Sim {
namespace Container {

template <typename T, size_t N>
class SegmentedVector;

template <
        typename T,
        std::size_t N,
        typename P = const T*,
        typename R = const T&,
        bool is_const_iterator = true
        >
class SVIterator : public std::iterator<
                        std::random_access_iterator_tag, T, std::ptrdiff_t, 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 self_type = SVIterator<T, N, P, R, is_const_iterator>;

        // ==================================================================
        // Construction / Copy / Move / Destruction
        // ==================================================================
        SVIterator() : m_p(m_end), m_c(nullptr) {}

        SVIterator(const self_type& other) : m_p(other.m_p), m_c(other.m_c) {}

        // ==================================================================
        // Bidirectional iterator methods
        // ==================================================================

        R operator*() const
        {
                assert(m_c != nullptr && m_p < m_c->size());
                size_t b = m_p / N; // index of buffer
                size_t i = m_p % N; // index in buffer b
                return *static_cast<T*>(static_cast<void*>(&(m_c->m_blocks[b][i])));
        }

        P operator->() const
        {
                assert(m_c != nullptr && m_p < m_c->size());
                size_t b = m_p / N; // index of buffer
                size_t i = m_p % N; // index in buffer b
                return static_cast<T*>(static_cast<void*>(&(m_c->m_blocks[b][i])));
        }

        self_type& operator++()
        {
                if (m_c != nullptr) { // This is a nullptr only when default constructed
                        if (m_p < m_c->m_size - 1)
                                ++m_p;
                        else
                                m_p = m_end;
                }
                return *this;
        }

        self_type operator++(int)
        {
                self_type tmp(*this);
                operator++();
                return tmp;
        }

        self_type& operator--()
        {
                if (m_c != nullptr) { // This is a nullptr only when default constructed
                        if (m_p > 0 && m_p != m_end)
                                --m_p;
                        else if (m_p == m_end)
                                m_p = m_c->m_size-1;
                }
                return *this;
        }

        self_type operator--(int)
        {
                self_type tmp(*this);
                operator--();
                return tmp;
        }

        bool operator==(const self_type& other) const
        {
                return (m_p == other.m_p) && (m_c == other.m_c);
        }

        bool operator!=(const self_type& other) const
        {
                return (m_p != other.m_p) || (m_c != other.m_c);
        }

        // ==================================================================
        // Random-Access iterator methods
        // ==================================================================

        R operator[](std::size_t n) const
        {
                assert(m_p + n != m_end);
                size_t b = (m_p + n) / N; // index of buffer
                size_t i = (m_p + n) % N; // index in buffer b
                return *static_cast<T*>(static_cast<void*>(&(m_c->m_blocks[b][i])));
        }

        self_type& operator+=(std::ptrdiff_t n)
        {
                m_p += n;
                if (m_p > m_c->m_size)
                        m_p = m_end;
                return *this;
        }

        self_type& operator-=(std::ptrdiff_t n)
        {
                m_p -= n;
                if (m_p < 0)
                        m_p = m_end;
                return *this;
        }

        self_type operator+(std::ptrdiff_t n)
        {
                return self_type(m_p + n, m_c);
        }

        self_type operator-(std::ptrdiff_t);

        long int operator-(const self_type& other) const
        {
                return m_p - other.m_p;
        }

        bool operator<(const self_type& other) const
        {
                return m_p < other.m_p;
        }

        bool operator<=(const self_type& other) const
        {
                return m_p <= other.m_p;
        }

        bool operator>(const self_type& other) const
        {
                return m_p > other.m_p;
        }

        bool operator>=(const self_type& other) const
        {
                return m_p >= other.m_p;
        }

private:
        friend class SegmentedVector<T, N>;

private:
        std::size_t m_p;

        constexpr static std::size_t m_end = std::numeric_limits<size_t>::max();

private:
        using container_pointer_type = typename std::conditional<
                is_const_iterator, const SegmentedVector<T, N>*, SegmentedVector<T, N>*>::type;

        // Container that the iterator points into.
        container_pointer_type m_c;

private:
        SVIterator(std::size_t p, container_pointer_type c) : m_p(p), m_c(c) {}

        bool IsDefaultContructed()
        {
                return m_c == nullptr && m_p == m_end;
        }

        bool IsPastTheEnd()
        {
                return m_c != nullptr && m_p == m_end;
        }

        bool IsDereferencable()
        {
                return m_c != nullptr && m_p < m_c->size();
        }
};

} // namespace
} // namespace

#endif