ZipView.hpp

Go to the documentation of this file.

 
#ifndef RTYPE_ECS_ZIPVIEW_HPP_
#define RTYPE_ECS_ZIPVIEW_HPP_
 
#include "RType/ECS/SparseArray.hpp"
#include <tuple>
#include <vector>
#include <algorithm>
#include <iterator>
#include <span>
 
namespace rtp::ecs {
 
    template <class... Containers>
    class ZipView {
    public:
        using tuple_arrays_t = std::tuple<Containers...>;
 
        class Iterator {
        public:
            using iterator_category = std::forward_iterator_tag;
            using value_type = std::tuple<typename std::remove_reference_t<Containers>::value_type&...>;
            using difference_type = std::ptrdiff_t;
            using pointer = void;
            using reference = value_type;
 
            Iterator(tuple_arrays_t& arrays,
                     std::span<const Entity> entities,
                     size_t index)
                : _arrays(arrays), _entities(entities), _index(index)
            {
                skipInvalid();
            }
 
            Iterator& operator++() {
                ++_index;
                skipInvalid();
                return *this;
            }
 
            Iterator operator++(int) {
                Iterator tmp = *this;
                ++(*this);
                return tmp;
            }
 
            bool operator==(const Iterator& other) const {
                return _index == other._index;
            }
 
            bool operator!=(const Iterator& other) const {
                return _index != other._index;
            }
 
            [[nodiscard]]
            reference operator*() {
                Entity e = _entities[_index];
                return std::apply([e](auto&&... args) {
                    return std::forward_as_tuple(args[e]...);
                }, _arrays);
            }
 
        private:
            tuple_arrays_t& _arrays;                
            std::span<const Entity> _entities;      
            size_t _index;                          
            void skipInvalid() {
                while (_index < _entities.size()) {
                    Entity e = _entities[_index];
                    
                    bool all_present = std::apply([e](auto&&... args) {
                        return (... && args.has(e)); 
                    }, _arrays);
 
                    if (all_present) {
                        return;
                    }
                    
                    ++_index;
                }
            }
        };
 
        ZipView(Containers... arrays) : _arrays(std::forward_as_tuple(arrays...)) {
            size_t min_size = std::get<0>(_arrays).size();
            _smallest_idx = 0;
            findSmallest<0>(min_size);
        }
 
        Iterator begin() {
            const auto entities = getEntitiesFromSmallest(_smallest_idx);
            return Iterator(_arrays, entities, 0);
        }
 
        Iterator end() {
            const auto entities = getEntitiesFromSmallest(_smallest_idx);
            return Iterator(_arrays, entities, entities.size());
        }
 
    private:
        tuple_arrays_t _arrays;          
        size_t _smallest_idx = 0;        
        template<size_t I>
        void findSmallest(size_t& min_size) {
            if constexpr (I < sizeof...(Containers)) {
                size_t current_size = std::get<I>(_arrays).size();
                if (current_size < min_size) {
                    min_size = current_size;
                    _smallest_idx = I;
                }
                findSmallest<I + 1>(min_size);
            }
        }
 
        std::span<const Entity> getEntitiesFromSmallest(size_t index) {
            std::span<const Entity> result{};
            size_t current = 0;
            
            std::apply([&](auto&&... args) {
                ((current++ == index ? result = args.entities() : std::span<const Entity>{}), ...);
            }, _arrays);
            
            return result;
        }
    };
}
 
#endif // RTYPE_ECS_ZIPVIEW_HPP_