chunk.hpp

Go to the documentation of this file.

#pragma once
 
#include <cassert>
#include <cstdint>
#include <new>
#include <optional>
#include <type_traits>
#include <utility>
 
#include <co_ecs/component.hpp>
#include <co_ecs/detail/bits.hpp>
#include <co_ecs/detail/sparse_map.hpp>
#include <co_ecs/detail/views.hpp>
#include <co_ecs/entity.hpp>
#include <co_ecs/exceptions.hpp>
 
 
namespace co_ecs {
 
// NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
// NOLINTBEGIN(cppcoreguidelines-pro-bounds-pointer-arithmetic)
 
struct block_metadata {
    std::size_t offset{};
    component_meta meta{};
 
    block_metadata(std::size_t offset, const component_meta& meta) noexcept : offset(offset), meta(meta) {
    }
};
 
using blocks_type = detail::sparse_map<component_id_t, block_metadata>;
 
class chunk {
public:
    static constexpr std::size_t chunk_bytes = static_cast<const std::size_t>(16U * 1024); // 16 KB
 
    static constexpr std::size_t alloc_alignment = alignof(entity);
 
    struct alignas(alloc_alignment) chunk_buffer {
        std::byte data[chunk_bytes];
    };
 
    chunk(const blocks_type& blocks, std::size_t max_size) :
        _blocks(&blocks), _max_size(max_size), _buffer((new chunk_buffer)->data) {
    }
 
    chunk(const chunk& rhs) = delete;
 
    auto operator=(const chunk& rhs) -> chunk& = delete;
 
    chunk(chunk&& rhs) noexcept :
        _buffer(std::exchange(rhs._buffer, nullptr)), _size(rhs._size), _max_size(rhs._max_size), _blocks(rhs._blocks) {
    }
 
    auto operator=(chunk&& rhs) noexcept -> chunk& {
        _buffer = std::exchange(rhs._buffer, _buffer);
        _size = std::exchange(rhs._size, _size);
        _max_size = std::exchange(rhs._max_size, _max_size);
        _blocks = std::exchange(rhs._blocks, _blocks);
        return *this;
    }
 
    ~chunk() {
        if (_buffer == nullptr) {
            return;
        }
        for (const auto& [id, block] : *_blocks) {
            for (std::size_t i = 0; i < _size; i++) {
                block.meta.type->destruct(_buffer + block.offset + i * block.meta.type->size);
            }
        }
        delete reinterpret_cast<chunk_buffer*>(_buffer);
    }
 
    template<component... Args>
    void emplace_back(entity ent, Args&&... args) {
        assert((!full()) && "Chunk is full, cannot add more entities");
        std::construct_at(ptr_unchecked<entity>(size()), ent);
        (..., std::construct_at(ptr_mut<Args>(size()), std::forward<Args>(args)));
        _size++;
    }
 
    void pop_back() noexcept {
        assert((!empty()) && "Chunk is empty, cannot pop out any entity");
        _size--;
        destroy_at(_size);
    }
 
    auto swap_erase(std::size_t index, chunk& other) noexcept -> std::optional<entity> {
        assert((index < _size) && "Entity index exceeds chunk size");
        if (size() == 1 || index == _size - 1) {
            pop_back();
            return std::nullopt;
        }
        assert((!other.empty()) && "Other chunk is empty, cannot move entity out of it");
        const std::size_t other_chunk_index = other._size - 1;
        entity ent = *other.ptr_unchecked<entity>(other_chunk_index);
        for (const auto& [id, block] : *_blocks) {
            auto other_block = other._blocks->find(id)->second;
            const auto* type = block.meta.type;
            auto* ptr = other._buffer + other_block.offset + other_chunk_index * type->size;
            type->move_assign(_buffer + block.offset + index * type->size, ptr);
        }
        other.pop_back();
        return ent;
    }
 
    auto move(std::size_t index, chunk& other_chunk) -> std::size_t {
        assert((index < _size) && "Entity index exceeds chunk size");
        assert((!other_chunk.full()) && "Other chunk is full, cannot move entity to it");
        const std::size_t other_chunk_index = other_chunk._size;
        for (const auto& [id, block] : *_blocks) {
            const auto* type = block.meta.type;
            if (!other_chunk._blocks->contains(id)) {
                continue;
            }
            auto* ptr = other_chunk._buffer + other_chunk._blocks->at(id).offset + other_chunk_index * type->size;
            type->move_construct(ptr, _buffer + block.offset + index * type->size);
        }
        other_chunk._size++;
        return other_chunk_index;
    }
 
    auto copy(std::size_t index, chunk& other_chunk) -> std::size_t {
        assert((index < _size) && "Entity index exceeds chunk size");
        assert((!other_chunk.full()) && "Other chunk is full, cannot move entity to it");
        const std::size_t other_chunk_index = other_chunk._size;
        for (const auto& [id, block] : *_blocks) {
            const auto* type = block.meta.type;
            if (!other_chunk._blocks->contains(id)) {
                continue;
            }
            auto* ptr = other_chunk._buffer + other_chunk._blocks->at(id).offset + other_chunk_index * type->size;
            if (type->copy_construct) {
                type->copy_construct(ptr, _buffer + block.offset + index * type->size);
            }
        }
        other_chunk._size++;
        return other_chunk_index;
    }
 
    constexpr void visit(std::size_t index, auto&& func) noexcept {
        visit_impl(*this, index, std::forward<decltype(func)>(func));
    }
 
    constexpr void visit(std::size_t index, auto&& func) const noexcept {
        visit_impl(*this, index, std::forward<decltype(func)>(func));
    }
 
    template<component T>
    inline auto ptr_const(std::size_t index) const -> const T* {
        return ptr_unchecked_impl<const T*>(*this, index);
    }
 
    template<component T>
    inline auto ptr_mut(std::size_t index) -> T* {
        static_assert(!std::is_same_v<T, entity>, "Cannot give a mutable pointer/reference to the entity");
        return ptr_unchecked_impl<T*>(*this, index);
    }
 
    [[nodiscard]] constexpr auto max_size() const noexcept -> std::size_t {
        return _max_size;
    }
 
    [[nodiscard]] constexpr auto size() const noexcept -> std::size_t {
        return _size;
    }
 
    [[nodiscard]] constexpr auto full() const noexcept -> bool {
        return size() == max_size();
    }
 
    [[nodiscard]] constexpr auto empty() const noexcept -> bool {
        return size() == 0;
    }
 
private:
    friend class base_registry;
 
    constexpr static void visit_impl(auto&& self, std::size_t index, auto&& func) noexcept {
        assert((index < self._size) && "Entity index exceeds chunk size");
 
        constexpr auto is_const = std::is_const_v<std::remove_reference_t<decltype(self)>>;
        using ptr_t = std::conditional_t<is_const, const void*, void*>;
 
        for (const auto& [id, block] :
            *self._blocks | detail::views::drop(1)) // skip first block - it's an entity handle
        {
            const auto* type = block.meta.type;
            ptr_t ptr = self._buffer + block.offset + index * type->size;
            func(block.meta, ptr);
        }
    }
 
    template<component T>
    [[nodiscard]] constexpr auto ptr_unchecked(std::size_t index) -> T* {
        return ptr_unchecked_impl<T*>(*this, index);
    }
 
    template<component T>
    [[nodiscard]] constexpr auto ptr_unchecked(std::size_t index) const noexcept -> const T* {
        return ptr_unchecked_impl<const T*>(*this, index);
    }
 
    template<typename P>
    [[nodiscard]] static inline auto ptr_unchecked_impl(auto&& self, std::size_t index) -> P {
        using component_type = std::remove_const_t<std::remove_pointer_t<P>>;
        const auto& block = self.get_block(component_id::value<component_type>);
        return (reinterpret_cast<P>(self._buffer + block.offset) + index);
    }
 
    [[nodiscard]] auto get_block(component_id_t id) const -> const block_metadata& {
        return _blocks->at(id);
    }
 
    inline void destroy_at(std::size_t index) noexcept {
        for (const auto& [id, block] : *_blocks) {
            block.meta.type->destruct(_buffer + block.offset + index * block.meta.type->size);
        }
    }
 
    std::byte* _buffer{};
    std::size_t _size{};
    std::size_t _max_size{};
    const blocks_type* _blocks;
};
 
struct component_fetch {
    // clang-format off
 
    template<component_reference C>
    static auto fetch_pointer(auto&& chunk, std::size_t index)
        -> const decay_component_t<C>* requires(const_component_reference_v<C>) {
            try {
                return chunk.template ptr_const<decay_component_t<C>>(index);
            } catch (const std::out_of_range&) {
                throw component_not_found{ type_meta::of<decay_component_t<C>>() };
            }
        }
 
    template<component_reference C>
    static auto fetch_pointer(auto&& chunk, std::size_t index)
        -> decay_component_t<C>* requires(mutable_component_reference_v<C>) {
            try {
                return chunk.template ptr_mut<decay_component_t<C>>(index);
            } catch (const std::out_of_range&) {
                throw component_not_found{ type_meta::of<decay_component_t<C>>() };
            }
        }
 
    // clang-format on
};
 
template<component_reference... Args>
class chunk_view {
public:
    static constexpr bool is_const = const_component_references_v<Args...>;
 
    using chunk_type = std::conditional_t<is_const, const chunk&, chunk&>;
 
    class iterator {
    public:
        using iterator_concept = std::forward_iterator_tag;
        using iterator_category = std::forward_iterator_tag;
        using difference_type = int;
        using value_type = std::tuple<Args...>;
        using reference = std::tuple<Args...>;
        using element_type = reference;
 
        constexpr iterator() = default;
 
        constexpr ~iterator() = default;
 
        explicit constexpr iterator(chunk_type c, std::size_t index = 0) :
            _ptrs(std::make_tuple(component_fetch::fetch_pointer<Args>(c, index)...)) {
        }
 
        constexpr iterator(const iterator& rhs) noexcept = default;
 
        constexpr auto operator=(const iterator& rhs) noexcept -> iterator& = default;
 
        constexpr iterator(iterator&& rhs) noexcept = default;
 
        constexpr auto operator=(iterator&& rhs) noexcept -> iterator& = default;
 
        constexpr auto operator++() noexcept -> iterator& {
            std::apply([](auto&&... args) { (args++, ...); }, _ptrs);
            return *this;
        }
 
        constexpr auto operator++(int) noexcept -> iterator {
            iterator tmp(*this);
            std::apply([](auto&&... args) { (args++, ...); }, _ptrs);
            return tmp;
        }
 
        constexpr auto operator*() const noexcept -> reference {
            return std::apply([](auto&&... args) { return std::make_tuple(std::ref(*args)...); }, _ptrs);
        }
 
        constexpr bool operator==(const iterator& rhs) const noexcept {
            return std::get<0>(_ptrs) == std::get<0>(rhs._ptrs);
        }
 
        constexpr auto operator<=>(const iterator& rhs) const noexcept {
            return std::get<0>(_ptrs) <=> std::get<0>(rhs._ptrs);
        }
 
    private:
        std::tuple<std::add_pointer_t<std::remove_reference_t<Args>>...> _ptrs;
    };
 
    explicit chunk_view(chunk_type c) : _chunk(c) {
    }
 
    [[nodiscard]] constexpr auto begin() noexcept -> iterator {
        return iterator(_chunk, 0);
    }
 
    [[nodiscard]] constexpr auto end() noexcept -> iterator {
        return iterator(_chunk, _chunk.size());
    }
 
private:
    chunk_type _chunk;
};
 
// NOLINTEND(cppcoreguidelines-pro-bounds-pointer-arithmetic)
// NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)
 
} // namespace co_ecs