chunk_iterator.h

#pragma once
#include "gaia/config/config.h"
 
#include <cinttypes>
#include <cstdint>
#include <type_traits>
 
#include "gaia/ecs/api.h"
#include "gaia/ecs/archetype.h"
#include "gaia/ecs/chunk.h"
#include "gaia/ecs/command_buffer_fwd.h"
#include "gaia/ecs/component.h"
#include "gaia/ecs/component_cache_item.h"
#include "gaia/ecs/id.h"
#include "gaia/ecs/query_common.h"
#include "gaia/mem/data_layout_policy.h"
 
namespace gaia {
  namespace ecs {
    class World;
    void world_finish_write(World& world, Entity term, Entity entity);
    template <typename T>
    decltype(auto) world_query_entity_arg_by_id_raw(World& world, Entity entity, Entity id);
    template <typename T>
    decltype(auto) world_query_entity_arg_by_id_cached_const(
        World& world, Entity entity, Entity id, const Archetype*& pLastArchetype, Entity& cachedOwner,
        bool& cachedDirect);
    template <typename T>
    void world_init_query_entity_arg_by_id_chunk_stable_const(
        World& world, const Chunk& chunk, const Entity* pEntities, Entity id, bool& direct, uint32_t& compIdx,
        const std::remove_cv_t<std::remove_reference_t<T>>*& pDataInherited);
    template <typename T>
    const std::remove_cv_t<std::remove_reference_t<T>>*
    world_query_inherited_arg_data_const(World& world, Entity owner, Entity id);
    bool world_term_uses_inherit_policy(const World& world, Entity term);
    template <typename T>
    Entity world_query_arg_id(World& world);
 
    enum class Constraints : uint8_t { EnabledOnly, DisabledOnly, AcceptAll };
 
    namespace detail {
      class ChunkIterImpl;
 
      struct IterTermDesc {
        Entity termId = EntityBad;
        bool isEntity = false;
        bool isOutOfLine = false;
      };
 
      struct ChunkIterTypedOps {
        template <typename T>
        static IterTermDesc term_desc(const ChunkIterImpl& self);
        template <typename T>
        static auto view_any(const ChunkIterImpl& self);
        template <typename T>
        static auto view_any(ChunkIterImpl& self, uint32_t termIdx);
        template <typename T>
        static auto view(const ChunkIterImpl& self);
        template <typename T>
        static auto view(const ChunkIterImpl& self, uint32_t termIdx);
        template <typename T>
        static auto view_any_mut(ChunkIterImpl& self);
        template <typename T>
        static auto view_mut(ChunkIterImpl& self);
        template <typename T>
        static auto view_mut(ChunkIterImpl& self, uint32_t termIdx);
        template <typename T>
        static auto view_any_mut(ChunkIterImpl& self, uint32_t termIdx);
        template <typename T>
        static auto sview_any_mut(ChunkIterImpl& self);
        template <typename T>
        static auto sview_mut(ChunkIterImpl& self);
        template <typename T>
        static auto sview_mut(ChunkIterImpl& self, uint32_t termIdx);
        template <typename T>
        static auto sview_any_mut(ChunkIterImpl& self, uint32_t termIdx);
      };
 
      struct BfsChunkRun {
        const Archetype* pArchetype = nullptr;
        Chunk* pChunk = nullptr;
        uint16_t from = 0;
        uint16_t to = 0;
        uint32_t offset = 0;
      };
 
      template <typename U>
      struct EntityTermViewGetPointer {
        const U* pData = nullptr;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return pData;
        }
      };
 
      template <typename U>
      struct EntityTermViewGetEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
        mutable const Archetype* pLastArchetype = nullptr;
        mutable Entity cachedOwner = EntityBad;
        mutable bool cachedDirect = false;
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return world_query_entity_arg_by_id_cached_const<const U&>(
              *pWorld, pEntities[idx], id, pLastArchetype, cachedOwner, cachedDirect);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return nullptr;
        }
      };
 
      template <typename U>
      struct EntityTermViewSetPointer {
        U* pData = nullptr;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return static_cast<const U&>(pData[idx]);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD U* data() noexcept {
          return pData;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return pData;
        }
      };
 
      template <typename U, bool WriteIm>
      struct EntityTermViewSetEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          if constexpr (WriteIm)
            return world_query_entity_arg_by_id<U&>(*pWorld, pEntities[idx], id);
          else
            return world_query_entity_arg_by_id_raw<U&>(*pWorld, pEntities[idx], id);
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD U* data() noexcept {
          return nullptr;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return nullptr;
        }
      };
 
      template <typename U>
      struct EntityTermViewGet {
        const U* pData = nullptr;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
        const U* pDataInherited = nullptr;
        mutable const Archetype* pLastArchetype = nullptr;
        mutable Entity cachedOwner = EntityBad;
        mutable bool cachedDirect = false;
 
        static EntityTermViewGet pointer(const U* pData, uint32_t cnt) {
          return {pData, nullptr, nullptr, EntityBad, cnt, nullptr, nullptr, EntityBad, false};
        }
 
        static EntityTermViewGet entity(const Entity* pEntities, World* pWorld, Entity id, uint32_t cnt) {
          return {nullptr, pEntities, pWorld, id, cnt, nullptr, nullptr, EntityBad, false};
        }
 
        static EntityTermViewGet inherited(const U* pDataInherited, uint32_t cnt) {
          return {nullptr, nullptr, nullptr, EntityBad, cnt, pDataInherited, nullptr, EntityBad, false};
        }
 
        static EntityTermViewGet entity_chunk_stable(
            const Entity* pEntities, const Chunk* pChunk, World* pWorld, Entity id, uint16_t rowBase, uint32_t cnt) {
          uint32_t compIdx = BadIndex;
          const U* pDataInherited = nullptr;
          bool direct = false;
          world_init_query_entity_arg_by_id_chunk_stable_const<U>(
              *pWorld, *pChunk, pEntities, id, direct, compIdx, pDataInherited);
          const U* pData = nullptr;
          if (direct)
            pData = reinterpret_cast<const U*>(pChunk->comp_ptr(compIdx, rowBase));
 
          return {pData, nullptr, pWorld, id, cnt, pDataInherited, nullptr, EntityBad, false};
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return pData[idx];
          if (pDataInherited != nullptr) {
            GAIA_ASSERT(pDataInherited != nullptr);
            return *pDataInherited;
          }
 
          return world_query_entity_arg_by_id_cached_const<const U&>(
              *pWorld, pEntities[idx], id, pLastArchetype, cachedOwner, cachedDirect);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return pData;
        }
      };
 
      template <typename U>
      struct EntityTermViewSet {
        U* pData = nullptr;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
        bool writeIm = true;
 
        static EntityTermViewSet pointer(U* pData, uint32_t cnt) {
          return {pData, nullptr, nullptr, EntityBad, cnt, true};
        }
 
        static EntityTermViewSet
        entity(const Entity* pEntities, World* pWorld, Entity id, uint32_t cnt, bool writeIm = true) {
          return {nullptr, pEntities, pWorld, id, cnt, writeIm};
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return pData[idx];
 
          if (writeIm)
            return EntityTermViewSetEntity<U, true>{pEntities, pWorld, id, cnt}[idx];
          return EntityTermViewSetEntity<U, false>{pEntities, pWorld, id, cnt}[idx];
        }
 
        GAIA_NODISCARD decltype(auto) operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return static_cast<const U&>(pData[idx]);
 
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
 
        GAIA_NODISCARD U* data() noexcept {
          return pData;
        }
 
        GAIA_NODISCARD const U* data() const noexcept {
          return pData;
        }
      };
 
      template <typename U>
      struct SoATermRowWriteProxyPointer {
        using raw_view_policy = mem::data_view_policy_soa<U::gaia_Data_Layout, U>;
 
        uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        uint32_t idx = 0;
 
        GAIA_NODISCARD operator U() const {
          return raw_view_policy::get(std::span<const uint8_t>{pData, dataSize}, idx);
        }
 
        SoATermRowWriteProxyPointer& operator=(const U& value) {
          raw_view_policy::set(std::span<uint8_t>{pData, dataSize}, idx) = value;
          return *this;
        }
      };
 
      template <typename U, bool WriteIm>
      struct SoATermRowWriteProxyEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t idx = 0;
 
        GAIA_NODISCARD operator U() const {
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        SoATermRowWriteProxyEntity& operator=(const U& value) {
          if constexpr (WriteIm)
            world_query_entity_arg_by_id<U&>(*pWorld, pEntities[idx], id) = value;
          else
            world_query_entity_arg_by_id_raw<U&>(*pWorld, pEntities[idx], id) = value;
          return *this;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldReadProxyPointer {
        using view_policy = mem::data_view_policy_soa_get<U::gaia_Data_Layout, U>;
        using value_type = typename view_policy::template data_view_policy_idx_info<Item>::const_value_type;
 
        const value_type* pData = nullptr;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD value_type operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldReadProxyEntity {
        using view_policy = mem::data_view_policy_soa_get<U::gaia_Data_Layout, U>;
        using value_type = typename view_policy::template data_view_policy_idx_info<Item>::const_value_type;
 
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD value_type operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          const U value = world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
          return std::get<Item>(meta::struct_to_tuple(value));
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldWriteProxyPointer {
        using view_policy = mem::data_view_policy_soa_set<U::gaia_Data_Layout, U>;
        using value_type = typename view_policy::template data_view_policy_idx_info<Item>::value_type;
 
        value_type* pData = nullptr;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD value_type& operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD const value_type& operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return pData[idx];
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, size_t Item, bool WriteIm>
      struct SoATermFieldWriteProxyEntity {
        using view_policy = mem::data_view_policy_soa_set<U::gaia_Data_Layout, U>;
        using value_type = typename view_policy::template data_view_policy_idx_info<Item>::value_type;
 
        struct ElementProxy {
          const Entity* pEntities = nullptr;
          World* pWorld = nullptr;
          Entity id = EntityBad;
          uint32_t idx = 0;
 
          GAIA_NODISCARD operator value_type() const {
            const U value = world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
            return std::get<Item>(meta::struct_to_tuple(value));
          }
 
          ElementProxy& operator=(const value_type& value) {
            auto data = world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
            auto tuple = meta::struct_to_tuple(data);
            std::get<Item>(tuple) = value;
            if constexpr (WriteIm)
              world_query_entity_arg_by_id<U&>(*pWorld, pEntities[idx], id) = meta::tuple_to_struct<U>(GAIA_MOV(tuple));
            else
              world_query_entity_arg_by_id_raw<U&>(*pWorld, pEntities[idx], id) =
                  meta::tuple_to_struct<U>(GAIA_MOV(tuple));
            return *this;
          }
 
          template <typename V>
          ElementProxy& operator+=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current + GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator-=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current - GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator*=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current * GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator/=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current / GAIA_FWD(value));
          }
        };
 
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD ElementProxy operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return ElementProxy{pEntities, pWorld, id, (uint32_t)idx};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewGetPointer {
        using raw_view_policy = mem::data_view_policy_soa<U::gaia_Data_Layout, U>;
        using read_view_policy = mem::data_view_policy_soa_get<U::gaia_Data_Layout, U>;
 
        const uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        uint32_t idxBase = 0;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return raw_view_policy::get(std::span<const uint8_t>{pData, dataSize}, idxBase + idx);
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          const auto field = read_view_policy{std::span<const uint8_t>{pData, dataSize}}.template get<Item>();
          return SoATermFieldReadProxyPointer<U, Item>{field.data() + idxBase, cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewGetEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          return SoATermFieldReadProxyEntity<U, Item>{pEntities, pWorld, id, cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewSetPointer {
        using raw_view_policy = mem::data_view_policy_soa<U::gaia_Data_Layout, U>;
        using read_view_policy = mem::data_view_policy_soa_get<U::gaia_Data_Layout, U>;
        using write_view_policy = mem::data_view_policy_soa_set<U::gaia_Data_Layout, U>;
 
        uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        uint32_t idxBase = 0;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD auto operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return SoATermRowWriteProxyPointer<U>{pData, dataSize, idxBase + (uint32_t)idx};
        }
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return raw_view_policy::get(std::span<const uint8_t>{pData, dataSize}, idxBase + idx);
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          const auto field = read_view_policy{std::span<const uint8_t>{pData, dataSize}}.template get<Item>();
          return SoATermFieldReadProxyPointer<U, Item>{field.data() + idxBase, cnt};
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto set() {
          auto field = write_view_policy{std::span<uint8_t>{pData, dataSize}}.template set<Item>();
          return SoATermFieldWriteProxyPointer<U, Item>{field.data() + idxBase, cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, bool WriteIm>
      struct SoATermViewSetEntity {
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD auto operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return SoATermRowWriteProxyEntity<U, WriteIm>{pEntities, pWorld, id, (uint32_t)idx};
        }
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return world_query_entity_arg_by_id<const U&>(*pWorld, pEntities[idx], id);
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          return SoATermFieldReadProxyEntity<U, Item>{pEntities, pWorld, id, cnt};
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto set() {
          return SoATermFieldWriteProxyEntity<U, Item, WriteIm>{pEntities, pWorld, id, cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermRowWriteProxy {
        uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t idx = 0;
        bool writeIm = true;
 
        GAIA_NODISCARD operator U() const {
          if (pData != nullptr)
            return (U)SoATermRowWriteProxyPointer<U>{pData, dataSize, idx};
 
          if (writeIm)
            return (U)SoATermRowWriteProxyEntity<U, true>{pEntities, pWorld, id, idx};
          return (U)SoATermRowWriteProxyEntity<U, false>{pEntities, pWorld, id, idx};
        }
 
        SoATermRowWriteProxy& operator=(const U& value) {
          if (pData != nullptr) {
            SoATermRowWriteProxyPointer<U>{pData, dataSize, idx} = value;
          } else if (writeIm)
            SoATermRowWriteProxyEntity<U, true>{pEntities, pWorld, id, idx} = value;
          else
            SoATermRowWriteProxyEntity<U, false>{pEntities, pWorld, id, idx} = value;
          return *this;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldReadProxy {
        using value_type = typename SoATermFieldReadProxyPointer<U, Item>::value_type;
 
        const value_type* pData = nullptr;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD value_type operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return SoATermFieldReadProxyPointer<U, Item>{pData, cnt}[idx];
 
          return SoATermFieldReadProxyEntity<U, Item>{pEntities, pWorld, id, cnt}[idx];
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U, size_t Item>
      struct SoATermFieldWriteProxy {
        using value_type = typename SoATermFieldWriteProxyPointer<U, Item>::value_type;
 
        value_type* pData = nullptr;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t cnt = 0;
        bool writeIm = true;
 
        struct ElementProxy {
          value_type* pData = nullptr;
          const Entity* pEntities = nullptr;
          World* pWorld = nullptr;
          Entity id = EntityBad;
          uint32_t idx = 0;
          bool writeIm = true;
 
          GAIA_NODISCARD operator value_type() const {
            if (pData != nullptr)
              return SoATermFieldWriteProxyPointer<U, Item>{pData, idx + 1}[idx];
 
            if (writeIm)
              return SoATermFieldWriteProxyEntity<U, Item, true>{pEntities, pWorld, id, idx + 1}[idx];
            return SoATermFieldWriteProxyEntity<U, Item, false>{pEntities, pWorld, id, idx + 1}[idx];
          }
 
          ElementProxy& operator=(const value_type& value) {
            if (pData != nullptr) {
              SoATermFieldWriteProxyPointer<U, Item>{pData, idx + 1}[idx] = value;
              return *this;
            }
 
            if (writeIm)
              SoATermFieldWriteProxyEntity<U, Item, true>{pEntities, pWorld, id, idx + 1}[idx] = value;
            else
              SoATermFieldWriteProxyEntity<U, Item, false>{pEntities, pWorld, id, idx + 1}[idx] = value;
            return *this;
          }
 
          template <typename V>
          ElementProxy& operator+=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current + GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator-=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current - GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator*=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current * GAIA_FWD(value));
          }
 
          template <typename V>
          ElementProxy& operator/=(V&& value) {
            const value_type current = operator value_type();
            return operator=(current / GAIA_FWD(value));
          }
        };
 
        GAIA_NODISCARD ElementProxy operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          return ElementProxy{pData, pEntities, pWorld, id, (uint32_t)idx, writeIm};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewGet {
        const uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t idxBase = 0;
        uint32_t cnt = 0;
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return SoATermViewGetPointer<U>{pData, dataSize, idxBase, cnt}[idx];
 
          return SoATermViewGetEntity<U>{pEntities, pWorld, id, cnt}[idx];
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          if (pData != nullptr) {
            const auto field = SoATermViewGetPointer<U>{pData, dataSize, idxBase, cnt}.template get<Item>();
            return SoATermFieldReadProxy<U, Item>{field.pData, nullptr, pWorld, id, cnt};
          }
 
          const auto field = SoATermViewGetEntity<U>{pEntities, pWorld, id, cnt}.template get<Item>();
          return SoATermFieldReadProxy<U, Item>{nullptr, field.pEntities, field.pWorld, field.id, field.cnt};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      template <typename U>
      struct SoATermViewSet {
        uint8_t* pData = nullptr;
        uint32_t dataSize = 0;
        const Entity* pEntities = nullptr;
        World* pWorld = nullptr;
        Entity id = EntityBad;
        uint32_t idxBase = 0;
        uint32_t cnt = 0;
        bool writeIm = true;
 
        GAIA_NODISCARD auto operator[](size_t idx) {
          GAIA_ASSERT(idx < cnt);
          return SoATermRowWriteProxy<U>{pData, dataSize, pEntities, pWorld, id, idxBase + (uint32_t)idx, writeIm};
        }
 
        GAIA_NODISCARD U operator[](size_t idx) const {
          GAIA_ASSERT(idx < cnt);
          if (pData != nullptr)
            return SoATermViewSetPointer<U>{pData, dataSize, idxBase, cnt}[idx];
 
          return SoATermViewSetEntity<U, true>{pEntities, pWorld, id, cnt}[idx];
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto get() const {
          if (pData != nullptr) {
            const auto field = SoATermViewSetPointer<U>{pData, dataSize, idxBase, cnt}.template get<Item>();
            return SoATermFieldReadProxy<U, Item>{field.pData, nullptr, pWorld, id, cnt};
          }
 
          const auto field = SoATermViewSetEntity<U, true>{pEntities, pWorld, id, cnt}.template get<Item>();
          return SoATermFieldReadProxy<U, Item>{nullptr, field.pEntities, field.pWorld, field.id, field.cnt};
        }
 
        template <size_t Item>
        GAIA_NODISCARD auto set() {
          if (pData != nullptr) {
            auto field = SoATermViewSetPointer<U>{pData, dataSize, idxBase, cnt}.template set<Item>();
            return SoATermFieldWriteProxy<U, Item>{field.pData, nullptr, pWorld, id, cnt};
          }
 
          if (writeIm) {
            const auto field = SoATermViewSetEntity<U, true>{pEntities, pWorld, id, cnt}.template set<Item>();
            return SoATermFieldWriteProxy<U, Item>{nullptr, field.pEntities, field.pWorld, field.id, field.cnt, true};
          }
 
          const auto field = SoATermViewSetEntity<U, false>{pEntities, pWorld, id, cnt}.template set<Item>();
          return SoATermFieldWriteProxy<U, Item>{nullptr, field.pEntities, field.pWorld, field.id, field.cnt, false};
        }
 
        GAIA_NODISCARD constexpr size_t size() const noexcept {
          return cnt;
        }
      };
 
      class ChunkIterImpl {
        friend struct ChunkIterTypedOps;
 
      protected:
        using CompIndicesBitView = core::bit_view<ChunkHeader::MAX_COMPONENTS_BITS>;
 
        const World* m_pWorld = nullptr;
        const Archetype* m_pArchetype = nullptr;
        Chunk* m_pChunk = nullptr;
        const uint8_t* m_pCompIndices = nullptr;
        InheritedTermDataView m_inheritedData;
        const Entity* m_pTermIdMapping = nullptr;
        bool m_writeIm = true;
        Constraints m_constraints = Constraints::EnabledOnly;
        uint8_t m_touchedCompIndices[ChunkHeader::MAX_COMPONENTS]{};
        uint8_t m_touchedCompCnt = 0;
        Entity m_touchedTerms[ChunkHeader::MAX_COMPONENTS]{};
        uint8_t m_touchedTermCnt = 0;
        Entity m_entitySnapshot[ChunkHeader::MAX_CHUNK_ENTITIES]{};
        bool m_entitySnapshotValid = false;
        uint16_t m_from;
        uint16_t m_to;
        GroupId m_groupId = 0;
        void* m_pCtx = nullptr;
 
      public:
        ChunkIterImpl() = default;
        ~ChunkIterImpl() = default;
        ChunkIterImpl(ChunkIterImpl&&) noexcept = default;
        ChunkIterImpl& operator=(ChunkIterImpl&&) noexcept = default;
        ChunkIterImpl(const ChunkIterImpl&) = delete;
        ChunkIterImpl& operator=(const ChunkIterImpl&) = delete;
 
        void set_world(const World* pWorld) {
          GAIA_ASSERT(pWorld != nullptr);
          m_pWorld = pWorld;
        }
 
        GAIA_NODISCARD World* world() {
          GAIA_ASSERT(m_pWorld != nullptr);
          return const_cast<World*>(m_pWorld);
        }
 
        GAIA_NODISCARD const World* world() const {
          GAIA_ASSERT(m_pWorld != nullptr);
          return m_pWorld;
        }
 
        void set_archetype(const Archetype* pArchetype) {
          GAIA_ASSERT(pArchetype != nullptr);
          m_pArchetype = pArchetype;
        }
 
        // GAIA_NODISCARD Archetype* archetype() {
        //  GAIA_ASSERT(m_pArchetype != nullptr);
        //  return m_pArchetype;
        // }
 
        GAIA_NODISCARD const Archetype* archetype() const {
          GAIA_ASSERT(m_pArchetype != nullptr);
          return m_pArchetype;
        }
 
        void set_chunk(Chunk* pChunk) {
          GAIA_ASSERT(pChunk != nullptr);
          m_pChunk = pChunk;
          m_entitySnapshotValid = false;
          m_from = start_index(m_pChunk, m_constraints);
          m_to = end_index(m_pChunk, m_constraints);
        }
 
        void set_chunk(Chunk* pChunk, uint16_t from, uint16_t to) {
          if (from == 0 && to == 0) {
            set_chunk(pChunk);
            return;
          }
 
          GAIA_ASSERT(pChunk != nullptr);
          m_pChunk = pChunk;
          m_entitySnapshotValid = false;
          m_from = from;
          m_to = to;
        }
 
        GAIA_NODISCARD const Chunk* chunk() const {
          GAIA_ASSERT(m_pChunk != nullptr);
          return m_pChunk;
        }
 
        void set_comp_indices(const uint8_t* pCompIndices) {
          m_pCompIndices = pCompIndices;
        }
 
        void set_inherited_data(InheritedTermDataView inheritedData) {
          m_inheritedData = inheritedData;
        }
 
        void set_term_ids(const Entity* pTermIds) {
          m_pTermIdMapping = pTermIds;
        }
 
        GAIA_NODISCARD const uint8_t* comp_indices() const {
          return m_pCompIndices;
        }
 
        GAIA_NODISCARD InheritedTermDataView inherited_data() const {
          return m_inheritedData;
        }
 
        GAIA_NODISCARD const Entity* term_ids() const {
          return m_pTermIdMapping;
        }
 
        void set_write_im(bool value) {
          m_writeIm = value;
          clear_touched_writes();
        }
 
        void set_constraints(Constraints constraints) {
          m_constraints = constraints;
          if (m_pChunk != nullptr) {
            m_from = start_index(m_pChunk, m_constraints);
            m_to = end_index(m_pChunk, m_constraints);
            m_entitySnapshotValid = false;
          }
        }
 
        void init_query_state(const World* pWorld, Constraints constraints, bool writeIm) {
          set_world(pWorld);
          m_constraints = constraints;
          m_writeIm = writeIm;
          clear_touched_writes();
        }
 
        void set_query_chunk(
            const Archetype* pArchetype, const uint8_t* pCompIndices, Chunk* pChunk, uint16_t from, uint16_t to) {
          GAIA_ASSERT(pArchetype != nullptr);
          GAIA_ASSERT(pChunk != nullptr);
          if (m_pArchetype != pArchetype)
            m_pArchetype = pArchetype;
          if (m_pCompIndices != pCompIndices)
            m_pCompIndices = pCompIndices;
          m_pChunk = pChunk;
          m_entitySnapshotValid = false;
          m_from = from;
          m_to = to;
        }
 
        GAIA_NODISCARD bool write_im() const {
          return m_writeIm;
        }
 
        GAIA_NODISCARD Constraints constraints() const {
          return m_constraints;
        }
 
        void clear_touched_writes() {
          m_touchedCompCnt = 0;
          m_touchedTermCnt = 0;
        }
 
        GAIA_NODISCARD const Entity* entity_snapshot() {
          if (!m_entitySnapshotValid) {
            const auto cnt = size();
            GAIA_ASSERT(cnt <= ChunkHeader::MAX_CHUNK_ENTITIES);
 
            const auto entities = m_pChunk->entity_view();
            GAIA_FOR(cnt) {
              m_entitySnapshot[i] = entities[from() + i];
            }
 
            m_entitySnapshotValid = true;
          }
 
          return m_entitySnapshot;
        }
 
        GAIA_NODISCARD auto touched_comp_indices() const {
          return std::span<const uint8_t>{m_touchedCompIndices, m_touchedCompCnt};
        }
 
        GAIA_NODISCARD auto touched_terms() const {
          return std::span<const Entity>{m_touchedTerms, m_touchedTermCnt};
        }
 
        GAIA_NODISCARD auto entity_rows() {
          if (m_entitySnapshotValid)
            return std::span<const Entity>{m_entitySnapshot, size()};
 
          return std::span<const Entity>{m_pChunk->entity_view().data() + from(), size()};
        }
 
        template <typename U>
        GAIA_NODISCARD auto entity_view_set(Entity termId, bool writeIm) {
          return EntityTermViewSet<U>::entity(entity_snapshot(), world(), termId, size(), writeIm);
        }
 
        template <typename U>
        GAIA_NODISCARD auto entity_soa_view_set(Entity termId, bool writeIm) {
          return SoATermViewSet<U>{nullptr, 0, entity_snapshot(), world(), termId, 0, size(), writeIm};
        }
 
        void set_group_id(GroupId groupId) {
          m_groupId = groupId;
        }
 
        GAIA_NODISCARD GroupId group_id() const {
          return m_groupId;
        }
 
 
        void ctx(void* pCtx) {
          m_pCtx = pCtx;
        }
 
        GAIA_NODISCARD void* ctx() const {
          return m_pCtx;
        }
 
        GAIA_NODISCARD CommandBufferST& cmd_buffer_st() const {
          auto* pWorld = const_cast<World*>(m_pWorld);
          return cmd_buffer_st_get(*pWorld);
        }
 
        GAIA_NODISCARD CommandBufferMT& cmd_buffer_mt() const {
          auto* pWorld = const_cast<World*>(m_pWorld);
          return cmd_buffer_mt_get(*pWorld);
        }
 
        GAIA_NODISCARD IterTermDesc resolved_term_desc(uint32_t termIdx, IterTermDesc desc) const {
          if (m_pTermIdMapping != nullptr) {
            const auto mappedTermId = m_pTermIdMapping[termIdx];
            if (mappedTermId != EntityBad)
              desc.termId = mappedTermId;
          }
 
          if (!desc.isEntity && desc.termId != EntityBad)
            desc.isOutOfLine = world_is_out_of_line_component(*world(), desc.termId);
 
          return desc;
        }
 
        void touch_comp_idx(uint8_t compIdx) {
          GAIA_ASSERT(compIdx != 0xFF);
          GAIA_FOR(m_touchedCompCnt) {
            if (m_touchedCompIndices[i] == compIdx)
              return;
          }
 
          GAIA_ASSERT(m_touchedCompCnt < ChunkHeader::MAX_COMPONENTS);
          m_touchedCompIndices[m_touchedCompCnt++] = compIdx;
        }
 
        void touch_term(Entity term) {
          GAIA_ASSERT(term != EntityBad);
          GAIA_FOR(m_touchedTermCnt) {
            if (m_touchedTerms[i] == term)
              return;
          }
 
          GAIA_ASSERT(m_touchedTermCnt < ChunkHeader::MAX_COMPONENTS);
          m_touchedTerms[m_touchedTermCnt++] = term;
        }
 
        void touch_term_desc(const IterTermDesc& desc) {
          if (desc.isEntity)
            return;
          if (desc.isOutOfLine)
            touch_term(desc.termId);
          else
            touch_comp_idx((uint8_t)m_pChunk->comp_idx(desc.termId));
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_any() const {
          return ChunkIterTypedOps::template view_any<T>(*this);
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_any(uint32_t termIdx) {
          return ChunkIterTypedOps::template view_any<T>(*this, termIdx);
        }
 
        template <typename T>
        GAIA_NODISCARD auto view() const {
          return ChunkIterTypedOps::template view<T>(*this);
        }
 
        template <typename T>
        GAIA_NODISCARD auto view(uint32_t termIdx) const {
          return ChunkIterTypedOps::template view<T>(*this, termIdx);
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_any_mut() {
          return ChunkIterTypedOps::template view_any_mut<T>(*this);
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_mut() {
          return ChunkIterTypedOps::template view_mut<T>(*this);
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_mut(uint32_t termIdx) {
          return ChunkIterTypedOps::template view_mut<T>(*this, termIdx);
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_any_mut(uint32_t termIdx) {
          return ChunkIterTypedOps::template view_any_mut<T>(*this, termIdx);
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_any_mut() {
          return ChunkIterTypedOps::template sview_any_mut<T>(*this);
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_mut() {
          return ChunkIterTypedOps::template sview_mut<T>(*this);
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_mut(uint32_t termIdx) {
          return ChunkIterTypedOps::template sview_mut<T>(*this, termIdx);
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_any_mut(uint32_t termIdx) {
          return ChunkIterTypedOps::template sview_any_mut<T>(*this, termIdx);
        }
 
        template <typename T, bool TriggerHooks>
        void modify() {
          m_pChunk->template modify<T, TriggerHooks>();
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_auto() {
          using UOriginal = typename actual_type_t<T>::TypeOriginal;
          if constexpr (core::is_mut_v<UOriginal>)
            return view_mut<T>();
          else
            return view<T>();
        }
 
        template <typename T>
        GAIA_NODISCARD auto view_auto_any() {
          using UOriginal = typename actual_type_t<T>::TypeOriginal;
          if constexpr (core::is_mut_v<UOriginal>)
            return view_any_mut<T>();
          else
            return view_any<T>();
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_auto_any() {
          using UOriginal = typename actual_type_t<T>::TypeOriginal;
          if constexpr (core::is_mut_v<UOriginal>)
            return sview_any_mut<T>();
          else
            return view_any<T>();
        }
 
        template <typename T>
        GAIA_NODISCARD auto sview_auto() {
          using UOriginal = typename actual_type_t<T>::TypeOriginal;
          if constexpr (core::is_mut_v<UOriginal>)
            return sview_mut<T>();
          else
            return view<T>();
        }
 
        GAIA_NODISCARD bool enabled(uint32_t index) const {
          const auto row = (uint16_t)(from() + index);
          return m_pChunk->enabled(row);
        }
 
        GAIA_NODISCARD bool has(Entity entity) const {
          return m_pChunk->has(entity);
        }
 
        GAIA_NODISCARD bool has(Pair pair) const {
          return m_pChunk->has((Entity)pair);
        }
 
        template <typename T>
        GAIA_NODISCARD bool has() const {
          return m_pChunk->template has<T>();
        }
 
        GAIA_NODISCARD static uint16_t start_index(Chunk* pChunk, Constraints constraints) noexcept {
          if (constraints == Constraints::EnabledOnly)
            return pChunk->size_disabled();
          return 0;
        }
 
        GAIA_NODISCARD static uint16_t end_index(Chunk* pChunk, Constraints constraints) noexcept {
          if (constraints == Constraints::DisabledOnly)
            return pChunk->size_disabled();
          return pChunk->size();
        }
 
        GAIA_NODISCARD static uint16_t size(Chunk* pChunk, Constraints constraints) noexcept {
          if (constraints == Constraints::EnabledOnly)
            return pChunk->size_enabled();
          if (constraints == Constraints::DisabledOnly)
            return pChunk->size_disabled();
          return pChunk->size();
        }
 
        GAIA_NODISCARD uint16_t size() const noexcept {
          return (uint16_t)(to() - from());
        }
 
        GAIA_NODISCARD uint16_t row_begin() const noexcept {
          return from();
        }
 
        GAIA_NODISCARD uint16_t row_end() const noexcept {
          return to();
        }
 
        template <typename T>
        uint32_t acc_index(uint32_t idx) const noexcept {
          using U = typename actual_type_t<T>::Type;
          if constexpr (mem::is_soa_layout_v<U>)
            return idx + from();
          else
            return idx;
        }
 
      protected:
        GAIA_NODISCARD uint16_t from() const noexcept {
          return m_from;
        }
 
        GAIA_NODISCARD uint16_t to() const noexcept {
          return m_to;
        }
      };
    } // namespace detail
 
    class GAIA_API Iter: public detail::ChunkIterImpl {
    public:
      static constexpr Constraints ConstraintMode = Constraints::EnabledOnly;
 
      using detail::ChunkIterImpl::size;
 
      Iter() {
        set_constraints(ConstraintMode);
      }
 
      GAIA_NODISCARD static uint16_t start_index(Chunk* pChunk) noexcept {
        return detail::ChunkIterImpl::start_index(pChunk, ConstraintMode);
      }
 
      GAIA_NODISCARD static uint16_t end_index(Chunk* pChunk) noexcept {
        return detail::ChunkIterImpl::end_index(pChunk, ConstraintMode);
      }
 
      GAIA_NODISCARD static uint16_t size(Chunk* pChunk) noexcept {
        return detail::ChunkIterImpl::size(pChunk, ConstraintMode);
      }
 
      GAIA_NODISCARD uint16_t size_enabled() const noexcept {
        return m_pChunk->size_enabled();
      }
 
      GAIA_NODISCARD uint16_t size_disabled() const noexcept {
        return m_pChunk->size_disabled();
      }
    };
 
    class GAIA_API CopyIter final {
    protected:
      using CompIndicesBitView = core::bit_view<ChunkHeader::MAX_COMPONENTS_BITS>;
 
      const World* m_pWorld = nullptr;
      const Archetype* m_pArchetype = nullptr;
      Chunk* m_pChunk = nullptr;
      uint16_t m_from;
      uint16_t m_cnt;
 
    public:
      CopyIter() = default;
      ~CopyIter() = default;
      CopyIter(CopyIter&&) noexcept = default;
      CopyIter& operator=(CopyIter&&) noexcept = default;
      CopyIter(const CopyIter&) = delete;
      CopyIter& operator=(const CopyIter&) = delete;
 
      void set_range(uint16_t from, uint16_t cnt) {
        GAIA_ASSERT(from < m_pChunk->size());
        GAIA_ASSERT(from + cnt <= m_pChunk->size());
        m_from = from;
        m_cnt = cnt;
      }
 
      void set_world(const World* pWorld) {
        GAIA_ASSERT(pWorld != nullptr);
        m_pWorld = pWorld;
      }
 
      GAIA_NODISCARD World* world() {
        GAIA_ASSERT(m_pWorld != nullptr);
        return const_cast<World*>(m_pWorld);
      }
 
      GAIA_NODISCARD const World* world() const {
        GAIA_ASSERT(m_pWorld != nullptr);
        return m_pWorld;
      }
 
      void set_archetype(const Archetype* pArchetype) {
        GAIA_ASSERT(pArchetype != nullptr);
        m_pArchetype = pArchetype;
      }
 
      // GAIA_NODISCARD Archetype* archetype() {
      //  GAIA_ASSERT(m_pArchetype != nullptr);
      //  return m_pArchetype;
      // }
 
      GAIA_NODISCARD const Archetype* archetype() const {
        GAIA_ASSERT(m_pArchetype != nullptr);
        return m_pArchetype;
      }
 
      void set_chunk(Chunk* pChunk) {
        GAIA_ASSERT(pChunk != nullptr);
        m_pChunk = pChunk;
      }
 
      GAIA_NODISCARD const Chunk* chunk() const {
        GAIA_ASSERT(m_pChunk != nullptr);
        return m_pChunk;
      }
 
      GAIA_NODISCARD CommandBufferST& cmd_buffer_st() const {
        auto* pWorld = const_cast<World*>(m_pWorld);
        return cmd_buffer_st_get(*pWorld);
      }
 
      GAIA_NODISCARD CommandBufferMT& cmd_buffer_mt() const {
        auto* pWorld = const_cast<World*>(m_pWorld);
        return cmd_buffer_mt_get(*pWorld);
      }
 
      template <typename T>
      GAIA_NODISCARD auto view() const {
        return m_pChunk->template view<T>(from(), to());
      }
 
      template <typename T>
      GAIA_NODISCARD auto view_mut() {
        return m_pChunk->template view_mut<T>(from(), to());
      }
 
      template <typename T>
      GAIA_NODISCARD auto sview_mut() {
        return m_pChunk->template sview_mut<T>(from(), to());
      }
 
      template <typename T, bool TriggerHooks>
      void modify() {
        m_pChunk->template modify<T, TriggerHooks>();
      }
 
      template <typename T>
      GAIA_NODISCARD auto view_auto() {
        return m_pChunk->template view_auto<T>(from(), to());
      }
 
      template <typename T>
      GAIA_NODISCARD auto sview_auto() {
        return m_pChunk->template sview_auto<T>(from(), to());
      }
 
      GAIA_NODISCARD bool enabled(uint32_t index) const {
        const auto row = (uint16_t)(from() + index);
        return m_pChunk->enabled(row);
      }
 
      GAIA_NODISCARD bool has(Entity entity) const {
        return m_pChunk->has(entity);
      }
 
      GAIA_NODISCARD bool has(Pair pair) const {
        return m_pChunk->has((Entity)pair);
      }
 
      template <typename T>
      GAIA_NODISCARD bool has() const {
        return m_pChunk->template has<T>();
      }
 
      GAIA_NODISCARD uint16_t size() const noexcept {
        return m_cnt;
      }
 
    private:
      GAIA_NODISCARD uint16_t from() const noexcept {
        return m_from;
      }
 
      GAIA_NODISCARD uint16_t to() const noexcept {
        return m_from + m_cnt;
      }
    };
  } // namespace ecs
} // namespace gaia
 
#include "gaia/ecs/chunk_iterator_typed.inl"