The ecs::iterator class allows for iterating over multiple containers (arrays ahah) at the same time by zipping them together.

It enables simultaneous access to corresponding elements from different containers.

This is useful in entity-component systems when you need to operate on multiple components in parallel.

namespace ecs {

    template <typename... Arrays>
    class iterator {

      public:
        iterator(std::tuple<Arrays &...> arrays, size_t pos) : _arrays(arrays), _pos(pos) {}

        bool operator==(const iterator &other) const
        {
            return _pos == other._pos;
        }

        bool operator!=(const iterator &other) const
        {
            return _pos != other._pos;
        }

        void operator++()
        {
            ++_pos;
        }

        auto operator*()
        {
            return mul_args_helper(std::make_index_sequence<sizeof...(Arrays)>());
        }

      private:
        template <std::size_t... I>
        auto mul_args_helper(std::index_sequence<I...>)
        {
            return std::tuple<std::add_lvalue_reference_t<decltype(std::get<I>(_arrays)[_pos])>...>{std::get<I>(_arrays
            )[_pos]...};
        }

        std::tuple<Arrays &...> _arrays;
        size_t _pos;
    };
} // namespace ecs

Public Members:

• Constructor:
  • iterator(std::tuple<Arrays &...> arrays, size_t pos)
    • Initializes the iterator with a tuple of references to multiple arrays and a starting position (pos).
    • arrays: A tuple holding references to multiple arrays to iterate over.
    • pos: The starting position of the iterator in the arrays.
• bool operator==(const iterator &other) const
  • Compares two iterators for equality based on their position.
  • Returns true if the iterators point to the same position in the arrays.
• bool operator!=(const iterator &other) const
  • Compares two iterators for inequality.
  • Returns true if the iterators point to different positions in the arrays.
• void operator++()
  • Increments the position of the iterator to point to the next element in all arrays.
• auto operator*()
  • Dereferences the iterator to access the elements at the current position in all arrays.
  • Returns a tuple containing references to the elements at the current position from each array.

Private Members:

• std::tuple<Arrays &...> _arrays
  • A tuple that stores references to all the arrays being iterated over.
• size_t _pos
  • The current position of the iterator in the arrays.

Private Methods:

• template <std::size_t... I> auto mul_args_helper(std::index_sequence<I...>)
  • Helper function used to extract elements from the arrays at the current position (_pos).
  • Uses the indices to unpack the tuple and return a tuple of element references from the corresponding arrays.