iterator.hpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup ipcq_detail
 * @brief Contains declarations for shm iterator.
 * @copyright
 *   SPDX-FileCopyrightText: 2019-2020 European Southern Observatory (ESO)
 *
 *   SPDX-License-Identifier: LGPL-3.0-only
 */
#ifndef IPCQ_DETAIL_ITERATOR_HPP_
#define IPCQ_DETAIL_ITERATOR_HPP_
 
namespace ipcq::detail {
 
/**
 * Provides standard iterator concept to ipcq queue.
 *
 * The special iterator value 0 means "end".
 *
 * @ingroup ipcq_detail
 */
template <class Buff, class Traits>
struct Iterator {
    /// @name Iterator concept
    //@{
    using iterator_category = std::random_access_iterator_tag;
    using value_type = typename Traits::value_type;
    using pointer = typename Traits::pointer;
    using reference = typename Traits::reference;
    using difference_type = typename Traits::difference_type;
    using size_type = typename Traits::size_type;
    //@}
 
    const Buff* m_buff;
    pointer m_it;
 
    // @todo: Add generation!
    Iterator() : m_buff(0), m_it(0){};
    explicit Iterator(const Buff* buff, const pointer p) : m_buff(buff), m_it(p) {
    }
 
    /**
     * Dereferencing operator
     */
    constexpr reference operator*() const noexcept {
        return *m_it;
    }
 
    /**
     * Dereferencing operator
     */
    constexpr pointer operator->() const noexcept {
        return &(operator*());
    }
 
    /**
     * Difference operator
     */
    template <class Traits0>
    constexpr difference_type operator-(const Iterator<Buff, Traits0>& it) const noexcept {
        return Linearize(*this) - Linearize(it);
    }
 
    /**
     * Increment operator (prefix)
     */
    constexpr Iterator& operator++() noexcept {
        m_buff->Increment(m_it);
        if (m_it == m_buff->m_last) {
            // This can also happen because writer catches up to reader. So that when reader next
            // time increments its m_last_element it compares equally to "one past" last element.
            m_it = nullptr;  // end
        }
        return *this;
    }
 
    /**
     * Increment operator (postfix)
     */
    constexpr Iterator operator++(int) noexcept {
        auto tmp = *this;
        ++*this;
        return tmp;
    }
 
    /**
     * Iterator addition
     */
    constexpr Iterator& operator+=(difference_type n) noexcept {
        if (n > 0) {
            m_it = m_buff->Add(m_it, n);
            if (m_it == m_buff->m_last) {
                m_it = nullptr;
            }
        } else if (n < 0) {
            //*this -= -n;
            assert(0);
        }
        return *this;
    }
 
    constexpr Iterator operator+(difference_type n) const noexcept {
        auto tmp = *this;
        tmp += n;
        return tmp;
    }
 
    /**
     * Random access operator
     */
    reference operator[](difference_type n) const {
        return *(*this + n);
    }
 
    template <class Traits0>
    constexpr bool operator==(const Iterator<Buff, Traits0>& it) const noexcept {
        return m_it == it.m_it;
    }
 
    template <class Traits0>
    constexpr bool operator!=(const Iterator<Buff, Traits0>& it) const noexcept {
        return m_it != it.m_it;
    }
 
    /**
     * Less
     */
    template <class Traits0>
    constexpr bool operator<(const Iterator<Buff, Traits0>& it) const noexcept {
        return Linearize(*this) < Linearize(it);
    }
 
    /**
     * Greater
     */
    template <class Traits0>
    constexpr bool operator>(const Iterator<Buff, Traits0>& it) const noexcept {
        return it < *this;
    }
 
    /**
     * Less or equal
     */
    template <class Traits0>
    constexpr bool operator<=(const Iterator<Buff, Traits0>& it) const noexcept {
        return !(it < *this);
    }
 
    /**
     * Greater or equal
     */
    template <class Traits0>
    constexpr bool operator>=(const Iterator<Buff, Traits0>& it) const noexcept {
        return !(*this < it);
    }
 
    /**
     * Get a pointer which would point to the same element as the Iterator
     * in case the circular buffer is linearized.
     */
    template <class Traits0>
    constexpr typename Traits0::pointer
    Linearize(const Iterator<Buff, Traits0>& it) const noexcept {
        auto end = m_buff->m_buffer + m_buff->m_capacity;
 
        return it.m_it == nullptr
                   ? m_buff->m_buffer + m_buff->m_size
                   : (it.m_it < m_buff->m_first ? it.m_it + (end - m_buff->m_first)
                                                : m_buff->m_buffer + (it.m_it - m_buff->m_first));
    }
 
    // GCOVR_EXCL_START
    std::ostream& Str(std::ostream& os) const noexcept {
        os << "{ it=" << m_it - m_buff->m_buffer << ", first=" << m_buff->m_first - m_buff->m_buffer
           << ", last=" << m_buff->m_last - m_buff->m_buffer << ", size=" << m_buff->m_size << " }";
        return os;
    }
 
    friend std::ostream& operator<<(std::ostream& os, Iterator const& it) {
        return it.Str(os);
    }
    // GCOVR_EXCL_STOP
};
 
}  // namespace ipcq::detail
#endif