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++/row.hpp"

#include <array>

namespace cif
{

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

template <typename Category, typename... Ts>
class iterator_impl
{
  public:
    template <typename, typename...>
    friend class iterator_impl;

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

    using category_type = std::remove_cv_t<Category>;
    using row_type = std::conditional_t<std::is_const_v<Category>, const row, row>;

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

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

    iterator_impl() = default;

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

    template <typename C2, typename... T2s>
    iterator_impl(const iterator_impl<C2, T2s...> &rhs)
        : m_current(const_cast<row_handle&>(rhs.m_current))
        , m_value(rhs.m_value)
        , m_item_ix(rhs.m_item_ix)
    {
    }

    template <typename IRowType>
    iterator_impl(iterator_impl<IRowType, Ts...> &rhs)
        : m_current(const_cast<row_handle&>(rhs.m_current))
        , m_value(rhs.m_value)
        , m_item_ix(rhs.m_item_ix)
    {
        m_value = get(std::make_index_sequence<N>());
    }

    template <typename IRowType>
    iterator_impl(const iterator_impl<IRowType> &rhs, const std::array<uint16_t, N> &cix)
        : m_current(const_cast<row_handle&>(rhs.m_current))
        , m_item_ix(cix)
    {
        m_value = get(std::make_index_sequence<N>());
    }

    iterator_impl &operator=(iterator_impl 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() = default;

    reference operator*()
    {
        return m_value;
    }

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

    operator const row_handle() const
    {
        return m_current;
    }

    operator row_handle()
    {
        return m_current;
    }

    iterator_impl &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 operator++(int)
    {
        iterator_impl result(*this);
        this->operator++();
        return result;
    }

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

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

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

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

    row_handle m_current;
    value_type m_value;
    std::array<uint16_t, N> m_item_ix;
};

template <typename Category>
class iterator_impl<Category>
{
  public:
    template <typename, typename...>
    friend class iterator_impl;

    friend class category;
    using category_type = std::remove_cv_t<Category>;
    using row_type = std::conditional_t<std::is_const_v<Category>, const row, row>;

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

    iterator_impl() = default;

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

    template <typename C2>
    iterator_impl(const iterator_impl<C2> &rhs)
        : m_current(const_cast<row_handle &>(rhs.m_current))
    {
    }

    iterator_impl(Category &cat, row *current)
        : m_current(cat, *current)
    {
    }

    template <typename IRowType>
    iterator_impl(const iterator_impl<IRowType> &rhs, const std::array<uint16_t, 0> &)
        : m_current(const_cast<row_handle &>(rhs.m_current))
    {
    }

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

    virtual ~iterator_impl() = default;

    reference operator*()
    {
        return m_current;
    }

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

    operator const row_handle() const
    {
        return m_current;
    }

    operator row_handle()
    {
        return m_current;
    }

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

        return *this;
    }

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

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

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

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

  private:
    row_handle m_current;
};

template <typename Category, typename T>
class iterator_impl<Category, T>
{
  public:
    template <typename, typename...>
    friend class iterator_impl;

    friend class category;

    using category_type = std::remove_cv_t<Category>;
    using row_type = std::conditional_t<std::is_const_v<Category>, const row, row>;

    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() = default;

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

    template <typename C2, typename T2>
    iterator_impl(const iterator_impl<C2, T2> &rhs)
        : m_current(rhs.m_current)
        , m_value(rhs.m_value)
        , m_item_ix(rhs.m_item_ix)
    {
    }

    template <typename IRowType>
    iterator_impl(iterator_impl<IRowType, T> &rhs)
        : m_current(const_cast<row_handle&>(rhs.m_current))
        , m_value(rhs.m_value)
        , m_item_ix(rhs.m_item_ix)
    {
        m_value = get();
    }

    template <typename IRowType>
    iterator_impl(const iterator_impl<IRowType> &rhs, const std::array<uint16_t, 1> &cix)
        : m_current(const_cast<row_handle&>(rhs.m_current))
        , m_item_ix(cix[0])
    {
        m_value = get();
    }

    iterator_impl &operator=(iterator_impl 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() = default;

    reference operator*()
    {
        return m_value;
    }

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

    operator const row_handle() const
    {
        return m_current;
    }

    operator row_handle()
    {
        return m_current;
    }

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

        m_value = get();

        return *this;
    }

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

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

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

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

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

    row_handle m_current;
    value_type m_value;
    uint16_t m_item_ix;
};

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

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

    using category_type = Category;
    using row_type = std::conditional_t<std::is_const_v<category_type>, const row, row>;

    using iterator = iterator_impl<category_type, Ts...>;
    using row_iterator = iterator_impl<category_type>;

    iterator_proxy(category_type &cat, row_iterator pos, char const *const items[N]);
    iterator_proxy(category_type &cat, row_iterator pos, std::initializer_list<char const *> items);

    iterator_proxy(iterator_proxy &&p);
    iterator_proxy &operator=(iterator_proxy &&p);

    iterator_proxy(const iterator_proxy &) = delete;
    iterator_proxy &operator=(const iterator_proxy &) = delete;
    iterator begin() const { return iterator(m_begin, m_item_ix); }
    iterator end() const { return iterator(m_end, m_item_ix); }

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

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

    category_type &category() const { return *m_category; }

    void swap(iterator_proxy &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);
    }

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

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

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

    using category_type = std::remove_cv_t<CategoryType>;

    using base_iterator = iterator_impl<CategoryType, Ts...>;
    using value_type = typename base_iterator::value_type;
    using row_type = typename base_iterator::row_type;
    using row_iterator = iterator_impl<CategoryType>;

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

        conditional_iterator_impl(CategoryType &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;

        reference operator*()
        {
            return *m_begin;
        }

        pointer operator->()
        {
            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 <typename IRowType, typename... ITs>
        bool operator==(const iterator_impl<IRowType, ITs...> &rhs) const { return m_begin == rhs; }

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

      private:
        CategoryType *m_cat;
        base_iterator m_begin, m_end;
        value_type m_current;
        const condition *m_condition;
    };

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

    template <typename... Ns>
    conditional_iterator_proxy(CategoryType &cat, row_iterator pos, condition &&cond, Ns... names);

    conditional_iterator_proxy(conditional_iterator_proxy &&p);
    conditional_iterator_proxy &operator=(conditional_iterator_proxy &&p);

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

    iterator begin() const;
    iterator end() const;

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

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

    CategoryType &category() const { return *m_cat; }

    void swap(conditional_iterator_proxy &rhs);

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

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

template <typename Category, typename... Ts>
iterator_proxy<Category, Ts...>::iterator_proxy(Category &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 <typename Category, typename... Ts>
iterator_proxy<Category, Ts...>::iterator_proxy(Category &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 <typename Category, typename... Ts>
conditional_iterator_proxy<Category, Ts...>::conditional_iterator_impl::conditional_iterator_impl(
    Category &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;
}

template <typename Category, typename... Ts>
conditional_iterator_proxy<Category, Ts...>::conditional_iterator_proxy(conditional_iterator_proxy &&p)
    : m_cat(nullptr)
    , mCBegin(p.mCBegin)
    , mCEnd(p.mCEnd)
    , mCix(p.mCix)
{
    std::swap(m_cat, p.m_cat);
    std::swap(mCix, p.mCix);
    m_condition.swap(p.m_condition);
}

template <typename Category, typename... Ts>
template <typename... Ns>
conditional_iterator_proxy<Category, Ts...>::conditional_iterator_proxy(Category &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)
    {
        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 <typename Category, typename... Ts>
conditional_iterator_proxy<Category, Ts...> &conditional_iterator_proxy<Category, Ts...>::operator=(conditional_iterator_proxy &&p)
{
    swap(p);
    return *this;
}

template <typename Category, typename... Ts>
typename conditional_iterator_proxy<Category, Ts...>::iterator conditional_iterator_proxy<Category, Ts...>::begin() const
{
    return iterator(*m_cat, mCBegin, m_condition, mCix);
}

template <typename Category, typename... Ts>
typename conditional_iterator_proxy<Category, Ts...>::iterator conditional_iterator_proxy<Category, Ts...>::end() const
{
    return iterator(*m_cat, mCEnd, m_condition, mCix);
}

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

template <typename Category, typename... Ts>
void conditional_iterator_proxy<Category, Ts...>::swap(conditional_iterator_proxy &rhs)
{
    std::swap(m_cat, rhs.m_cat);
    m_condition.swap(rhs.m_condition);
    std::swap(mCBegin, rhs.mCBegin);
    std::swap(mCEnd, rhs.mCEnd);
    std::swap(mCix, rhs.mCix);
}

} // namespace cif