SVIterator.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 <cassert>
#include <cstddef>
#include <iterator>
#include <limits>
#include <type_traits>

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