Program Listing for File iterator.hpp

↰ Return to documentation for file (cif++/iterator.hpp)

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (c) 2022 NKI/AVL, Netherlands Cancer Institute
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice, this
 *    list of conditions and the following disclaimer
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
 * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#pragma once

#include "cif++/condition.hpp"
#include "cif++/row.hpp"

#include <array>
#include <cstdint>
#include <numeric>
#include <type_traits>


namespace cif
{

class category;

// --------------------------------------------------------------------

template <bool Const, typename... Ts>
class iterator_impl_base
{
  public:
    template <bool, typename...>
    friend class iterator_impl_base;

    friend class category;

    static constexpr std::size_t N = sizeof...(Ts);

    using tuple_type = std::tuple<Ts...>;

    using row_handle_type = std::conditional_t<Const, const_row_handle, row_handle>;

    using iterator_category = std::forward_iterator_tag;
    using value_type = std::conditional_t<Const, const tuple_type, tuple_type>;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type *;
    using reference = value_type &;

    iterator_impl_base() = default;

    iterator_impl_base(const iterator_impl_base &rhs) = default;
    iterator_impl_base(iterator_impl_base &&rhs) = default;

    template <bool C, typename... T2s>
    iterator_impl_base(const iterator_impl_base<C, T2s...> &rhs)
        : m_current(rhs.m_current)
        , m_value(rhs.m_value)
        , m_item_ix(rhs.m_item_ix)
    {
    }

    template <bool C>
    iterator_impl_base(iterator_impl_base<C, Ts...> &rhs)
        : m_current(rhs.m_current)
        , m_value(rhs.m_value)
        , m_item_ix(rhs.m_item_ix)
    {
        m_value = get(std::make_index_sequence<N>());
    }

    template <bool C>
    iterator_impl_base(const iterator_impl_base<C> &rhs, const std::array<uint16_t, N> &cix)
        : m_current(rhs.m_current)
        , m_item_ix(cix)
    {
        m_value = get(std::make_index_sequence<N>());
    }

    iterator_impl_base &operator=(iterator_impl_base i)
    {
        std::swap(m_current, i.m_current);
        std::swap(m_item_ix, i.m_item_ix);
        std::swap(m_value, i.m_value);
        return *this;
    }

    virtual ~iterator_impl_base() = default;

    auto operator*()
    {
        return m_value;
    }

    auto operator*() const
    {
        return m_value;
    }

    auto operator->()
    {
        return &m_value;
    }

    auto operator->() const
    {
        return &m_value;
    }

    operator const_row_handle() const
    {
        return m_current;
    }

    operator row_handle_type()
    {
        return m_current;
    }

    iterator_impl_base &operator++()
    {
        if (m_current)
            m_current.m_row = m_current.m_row->m_next;

        m_value = get(std::make_index_sequence<N>());

        return *this;
    }

    iterator_impl_base operator++(int)
    {
        iterator_impl_base result(*this);
        this->operator++();
        return result;
    }

    bool operator==(const iterator_impl_base &rhs) const { return m_current == rhs.m_current; }
    bool operator!=(const iterator_impl_base &rhs) const { return m_current != rhs.m_current; }

    template <bool C, typename... ITs>
    bool operator==(const iterator_impl_base<C, ITs...> &rhs) const
    {
        return m_current == rhs.m_current;
    }

    template <bool C, typename... ITs>
    bool operator!=(const iterator_impl_base<C, ITs...> &rhs) const
    {
        return m_current != rhs.m_current;
    }


  private:
    template <std::size_t... Is>
    [[nodiscard]] tuple_type get(std::index_sequence<Is...>) const
    {
        return m_current ? tuple_type{ m_current[m_item_ix[Is]].template get<Ts>()... } : tuple_type{};
    }

    row_handle_type m_current;
    tuple_type m_value;
    std::array<uint16_t, N> m_item_ix;
};

template <bool Const>
class iterator_impl_base<Const>
{
  public:

    template <bool, typename...>
    friend class iterator_impl_base;

    friend class category;

    using category_type = std::conditional_t<Const, const category, category>;
    using row_type = std::conditional_t<Const, const row, row>;
    using row_handle_type = std::conditional_t<Const, const_row_handle, row_handle>;

    using iterator_category = std::forward_iterator_tag;

    using value_type = std::conditional_t<Const, const_row_handle, row_handle>;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type *;
    using reference = value_type &;

    iterator_impl_base() = default;

    iterator_impl_base(const iterator_impl_base &rhs) = default;
    iterator_impl_base(iterator_impl_base &&rhs) = default;

    template <bool C>
    iterator_impl_base(const iterator_impl_base<C> &rhs)
        : m_current(rhs.m_current)
    {
    }

    iterator_impl_base(const category_type &cat, const row_type *current)
        : m_current(const_cast<category &>(cat), const_cast<row_type &>(*current))
    {
    }

    template <bool C>
    iterator_impl_base(const iterator_impl_base<C> &rhs, const std::array<uint16_t, 0> &)
        : m_current(rhs.m_current)
    {
    }

    iterator_impl_base &operator=(iterator_impl_base i)
    {
        std::swap(m_current, i.m_current);
        return *this;
    }

    virtual ~iterator_impl_base() = default;

    auto operator*()
    {
        return m_current;
    }

    auto operator*() const
    {
        return m_current;
    }

    auto operator->()
    {
        return &m_current;
    }

    auto operator->() const
    {
        return &m_current;
    }

    operator const_row_handle() const
    {
        return m_current;
    }

    operator row_handle_type()
    {
        return m_current;
    }

    [[nodiscard]] int64_t row_id() const
    {
        return reinterpret_cast<int64_t>(m_current.m_row);
    }

    iterator_impl_base &operator++()
    {
        if (m_current)
            m_current.m_row = m_current.m_row->m_next;

        return *this;
    }

    iterator_impl_base operator++(int)
    {
        iterator_impl_base result(*this);
        this->operator++();
        return result;
    }

    bool operator==(const iterator_impl_base &rhs) const { return m_current == rhs.m_current; }
    bool operator!=(const iterator_impl_base &rhs) const { return m_current != rhs.m_current; }

    template <bool C, typename... ITs>
    bool operator==(const iterator_impl_base<C, ITs...> &rhs) const
    {
        return m_current == rhs.m_current;
    }

    template <bool C, typename... ITs>
    bool operator!=(const iterator_impl_base<C, ITs...> &rhs) const
    {
        return m_current != rhs.m_current;
    }


  private:
    row_handle_type m_current;
};


template <bool Const, typename T>
class iterator_impl_base<Const, T>
{
  public:
    template <bool, typename...>
    friend class iterator_impl_base;

    friend class category;

    using category_type = std::conditional_t<Const, const category, category>;
    using row_handle_type = std::conditional_t<Const, const_row_handle, row_handle>;

    using iterator_category = std::forward_iterator_tag;
    using value_type = T;
    using difference_type = std::ptrdiff_t;
    using pointer = value_type *;
    using reference = value_type &;

    iterator_impl_base() = default;

    iterator_impl_base(const iterator_impl_base &rhs) = default;
    iterator_impl_base(iterator_impl_base &&rhs) = default;

    template <bool C, typename T2>
    iterator_impl_base(const iterator_impl_base<C, T2> &rhs)
        : m_current(rhs.m_current)
        , m_value(rhs.m_value)
        , m_item_ix(rhs.m_item_ix)
    {
    }

    template <bool C>
    iterator_impl_base(iterator_impl_base<C, T> &rhs)
        : m_current(rhs.m_current)
        , m_value(rhs.m_value)
        , m_item_ix(rhs.m_item_ix)
    {
        m_value = get();
    }

    template <bool C>
    iterator_impl_base(const iterator_impl_base<C> &rhs, const std::array<uint16_t, 1> &cix)
        : m_current(rhs.m_current)
        , m_item_ix(cix[0])
    {
        m_value = get();
    }

    iterator_impl_base &operator=(iterator_impl_base i)
    {
        std::swap(m_current, i.m_current);
        std::swap(m_item_ix, i.m_item_ix);
        std::swap(m_value, i.m_value);
        return *this;
    }

    virtual ~iterator_impl_base() = default;

    auto operator*()
    {
        return m_value;
    }

    auto operator*() const
    {
        return m_value;
    }

    auto operator->()
    {
        return &m_value;
    }

    auto operator->() const
    {
        return &m_value;
    }

    operator const_row_handle() const
    {
        return m_current;
    }

    operator row_handle_type()
    {
        return m_current;
    }

    iterator_impl_base &operator++()
    {
        if (m_current)
            m_current.m_row = m_current.m_row->m_next;

        m_value = get();

        return *this;
    }

    iterator_impl_base operator++(int)
    {
        iterator_impl_base result(*this);
        this->operator++();
        return result;
    }

    bool operator==(const iterator_impl_base &rhs) const { return m_current == rhs.m_current; }
    bool operator!=(const iterator_impl_base &rhs) const { return m_current != rhs.m_current; }

    template <bool C, typename... ITs>
    bool operator==(const iterator_impl_base<C, ITs...> &rhs) const
    {
        return m_current == rhs.m_current;
    }

    template <bool C, typename... ITs>
    bool operator!=(const iterator_impl_base<C, ITs...> &rhs) const
    {
        return m_current != rhs.m_current;
    }


  private:
    [[nodiscard]] value_type get() const
    {
        return m_current ?  m_current[m_item_ix].template get<value_type>() : value_type{};
    }

    row_handle_type m_current;
    value_type m_value;
    uint16_t m_item_ix;
};

// --------------------------------------------------------------------

template<typename ... Ts>
using iterator_impl = iterator_impl_base<false, Ts...>;

template<typename ... Ts>
using const_iterator_impl = iterator_impl_base<true, Ts...>;

// --------------------------------------------------------------------
// iterator proxy


template <bool Const, typename... Ts>
class iterator_proxy_base
{
  public:
    static constexpr const std::size_t N = sizeof...(Ts);

    using category_type = std::conditional_t<Const, const category, category>;

    using iterator = iterator_impl_base<Const, Ts...>;
    using row_iterator = iterator_impl_base<Const>;

    iterator_proxy_base(category_type &cat, row_iterator pos, char const *const items[N]);
    iterator_proxy_base(category_type &cat, row_iterator pos, std::initializer_list<char const *> items); // NOLINT(modernize-pass-by-value)

    iterator_proxy_base(iterator_proxy_base &&p);
    iterator_proxy_base &operator=(iterator_proxy_base &&p);

    iterator_proxy_base(const iterator_proxy_base &) = delete;
    iterator_proxy_base &operator=(const iterator_proxy_base &) = delete;

    [[nodiscard]] iterator begin() const { return iterator(m_begin, m_item_ix); }
    [[nodiscard]] iterator end() const { return iterator(m_end, m_item_ix); }

    [[nodiscard]] bool empty() const { return m_begin == m_end; }
    explicit operator bool() const { return not empty(); }
    [[nodiscard]] std::size_t size() const { return std::distance(begin(), end()); }

    // row front() { return *begin(); }
    // row back() { return *(std::prev(end())); }

    [[nodiscard]] category_type &get_category() const { return *m_category; }

    void swap(iterator_proxy_base &rhs)
    {
        std::swap(m_category, rhs.m_category);
        std::swap(m_begin, rhs.m_begin);
        std::swap(m_end, rhs.m_end);
        std::swap(m_item_ix, rhs.m_item_ix);
    }

  protected:
    iterator_proxy_base(category_type &cat);

  private:
    category_type *m_category;
    row_iterator m_begin, m_end;
    std::array<uint16_t, N> m_item_ix;
};

// --------------------------------------------------------------------

template <typename... Ts>
using iterator_proxy = iterator_proxy_base<false, Ts...>;

template <typename... Ts>
using const_iterator_proxy = iterator_proxy_base<true, Ts...>;

// --------------------------------------------------------------------
// conditional iterator proxy

template <bool Const, typename... Ts>
class conditional_iterator_proxy_base
{
  public:
    static constexpr const std::size_t N = sizeof...(Ts);

    using category_type = std::conditional_t<Const, const category, category>;
    using base_iterator = iterator_impl_base<Const, Ts...>;
    using value_type = typename base_iterator::value_type;
    using row_iterator = iterator_impl_base<Const>;

    class conditional_iterator_impl
    {
      public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = conditional_iterator_proxy_base::value_type;
        using difference_type = std::ptrdiff_t;
        using pointer = value_type *;
        using reference = value_type;

        conditional_iterator_impl() = default;
        conditional_iterator_impl(category_type &cat, row_iterator pos, const condition &cond, const std::array<uint16_t, N> &cix);
        conditional_iterator_impl(const conditional_iterator_impl &i) = default;
        conditional_iterator_impl &operator=(const conditional_iterator_impl &i) = default;

        virtual ~conditional_iterator_impl() = default;

        auto operator*()
        {
            return *m_begin;
        }

        auto operator*() const
        {
            return *m_begin;
        }

        auto operator->()
        {
            m_current = *m_begin;
            return &m_current;
        }

        auto operator->() const
        {
            m_current = *m_begin;
            return &m_current;
        }

        conditional_iterator_impl &operator++()
        {
            while (m_begin != m_end)
            {
                if (++m_begin == m_end)
                    break;

                if (m_condition->operator()(m_begin))
                    break;
            }

            return *this;
        }

        conditional_iterator_impl operator++(int)
        {
            conditional_iterator_impl result(*this);
            this->operator++();
            return result;
        }

        bool operator==(const conditional_iterator_impl &rhs) const { return m_begin == rhs.m_begin; }
        bool operator!=(const conditional_iterator_impl &rhs) const { return m_begin != rhs.m_begin; }

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

        template <bool C, typename... ITs>
        bool operator==(const iterator_impl_base<C, ITs...> &rhs) const { return m_begin == rhs; }

        template <bool C, typename... ITs>
        bool operator!=(const iterator_impl_base<C, ITs...> &rhs) const { return m_begin != rhs; }

      private:
        category_type *m_cat = nullptr;
        base_iterator m_begin, m_end;
        std::remove_cv_t<value_type> m_current;
        const condition *m_condition;
    };

    using iterator = conditional_iterator_impl;
    using reference = typename iterator::reference;

    template <typename... Ns>
    conditional_iterator_proxy_base(category_type &cat, row_iterator pos, condition &&cond, Ns... names); // NOLINT(modernize-pass-by-value)

    conditional_iterator_proxy_base(conditional_iterator_proxy_base &&p)
    {
        swap(*this, p);
    }

    conditional_iterator_proxy_base &operator=(conditional_iterator_proxy_base &&p)
    {
        swap(*this, p);
        return *this;
    }

    conditional_iterator_proxy_base(const conditional_iterator_proxy_base &) = delete;
    conditional_iterator_proxy_base &operator=(const conditional_iterator_proxy_base &) = delete;


    [[nodiscard]] iterator begin() const;
    [[nodiscard]] iterator end() const;

    [[nodiscard]] bool empty() const;
    explicit operator bool() const { return not empty(); }
    [[nodiscard]] std::size_t size() const { return std::distance(begin(), end()); }

    auto front() { return *begin(); }
    // row_handle back() { return *begin(); }

    [[nodiscard]] category_type &get_category() const { return *m_cat; }

    template <bool C2, typename ... T2s>
    friend void swap(conditional_iterator_proxy_base<C2, T2s...> &lhs, conditional_iterator_proxy_base<C2, T2s...> &rhs);

  private:
    category_type *m_cat;
    condition m_condition;
    row_iterator mCBegin, mCEnd;
    std::array<uint16_t, N> mCix;
};

// --------------------------------------------------------------------

template <typename... Ts>
using conditional_iterator_proxy = conditional_iterator_proxy_base<false, Ts...>;

template <typename... Ts>
using const_conditional_iterator_proxy = conditional_iterator_proxy_base<true, Ts...>;

// --------------------------------------------------------------------

template <bool Const, typename... Ts>
iterator_proxy_base<Const, Ts...>::iterator_proxy_base(category_type &cat, row_iterator pos, char const *const items[N])
    : m_category(&cat)
    , m_begin(pos)
    , m_end(cat.end())
{
    for (uint16_t i = 0; i < N; ++i)
        m_item_ix[i] = m_category->get_item_ix(items[i]);
}

template <bool Const, typename... Ts>
iterator_proxy_base<Const, Ts...>::iterator_proxy_base(category_type &cat, row_iterator pos, std::initializer_list<char const *> items)
    : m_category(&cat)
    , m_begin(pos)
    , m_end(cat.end())
{
    // static_assert(items.size() == N, "The list of item names should be exactly the same as the list of requested items");

    std::uint16_t i = 0;
    for (auto item : items)
        m_item_ix[i++] = m_category->get_item_ix(item);
}

template <bool Const, typename... Ts>
iterator_proxy_base<Const, Ts...>::iterator_proxy_base(category_type &cat)
    : m_category(&cat)
    , m_begin(cat.begin())
    , m_end(cat.end())
{
    std::iota(m_item_ix.begin(), m_item_ix.end(), 0);
}

// --------------------------------------------------------------------

template <bool Const, typename... Ts>
conditional_iterator_proxy_base<Const, Ts...>::conditional_iterator_impl::conditional_iterator_impl(
    category_type &cat, row_iterator pos, const condition &cond, const std::array<uint16_t, N> &cix)
    : m_cat(&cat)
    , m_begin(pos, cix)
    , m_end(cat.end(), cix)
    , m_condition(&cond)
{
    if (m_condition == nullptr or m_condition->empty())
        m_begin = m_end;
    else
        m_current = *m_begin;
}

template <bool Const, typename... Ts>
template <typename... Ns>
conditional_iterator_proxy_base<Const, Ts...>::conditional_iterator_proxy_base(category_type &cat, row_iterator pos, condition &&cond, Ns... names)
    : m_cat(&cat)
    , m_condition(std::move(cond))
    , mCBegin(pos)
    , mCEnd(cat.end())
{
    static_assert(sizeof...(Ts) == sizeof...(Ns), "Number of item names should be equal to number of requested value types");

    if (m_condition and m_condition.prepare(cat))
    {
        while (mCBegin != mCEnd and not m_condition(*mCBegin))
            ++mCBegin;
    }
    else
        mCBegin = mCEnd;

    uint16_t i = 0;
    ((mCix[i++] = m_cat->get_item_ix(names)), ...);
}

template <bool Const, typename... Ts>
auto conditional_iterator_proxy_base<Const, Ts...>::begin() const -> iterator
{
    return iterator{ *m_cat, mCBegin, m_condition, mCix };
}

template <bool Const, typename... Ts>
auto conditional_iterator_proxy_base<Const, Ts...>::end() const -> iterator
{
    return iterator{ *m_cat, mCEnd, m_condition, mCix };
}

template <bool Const, typename... Ts>
bool conditional_iterator_proxy_base<Const, Ts...>::empty() const
{
    return mCBegin == mCEnd;
}

template <bool Const, typename... Ts>
void swap(conditional_iterator_proxy_base<Const, Ts...> &lhs, conditional_iterator_proxy_base<Const, Ts...> &rhs)
{
    std::swap(lhs.m_cat, rhs.m_cat);
    std::swap(lhs.m_condition, rhs.m_condition);
    std::swap(lhs.mCBegin, rhs.mCBegin);
    std::swap(lhs.mCEnd, rhs.mCEnd);
    std::swap(lhs.mCix, rhs.mCix);
}

// --------------------------------------------------------------------

// template <bool Const, typename... Ts>



} // namespace cif