sparse_set.hpp

#ifndef ENTT_ENTITY_SPARSE_SET_HPP
#define ENTT_ENTITY_SPARSE_SET_HPP


#include <algorithm>
#include <numeric>
#include <utility>
#include <vector>
#include <cstddef>
#include <cassert>
#include <type_traits>
#include "traits.hpp"


namespace entt {


template<typename...>
class SparseSet;


template<typename Entity>
class SparseSet<Entity> {
    using traits_type = entt_traits<Entity>;

    struct Iterator {
        using value_type = Entity;

        Iterator(const std::vector<Entity> *direct, std::size_t pos)
            : direct{direct}, pos{pos}
        {}

        Iterator & operator++() noexcept {
            return --pos, *this;
        }

        Iterator operator++(int) noexcept {
            Iterator orig = *this;
            return ++(*this), orig;
        }

        bool operator==(const Iterator &other) const noexcept {
            return other.pos == pos && other.direct == direct;
        }

        bool operator!=(const Iterator &other) const noexcept {
            return !(*this == other);
        }

        value_type operator*() const noexcept {
            return (*direct)[pos-1];
        }

    private:
        const std::vector<Entity> *direct;
        std::size_t pos;
    };

    static constexpr Entity in_use = (Entity{1} << traits_type::entity_shift);

public:
    using entity_type = Entity;
    using pos_type = entity_type;
    using size_type = std::size_t;
    using iterator_type = Iterator;

    SparseSet() noexcept = default;

    virtual ~SparseSet() noexcept = default;

    SparseSet(const SparseSet &) = delete;
    SparseSet(SparseSet &&) = default;

    SparseSet & operator=(const SparseSet &) = delete;
    SparseSet & operator=(SparseSet &&) = default;

    void reserve(size_type cap) {
        reverse.reserve(cap);
        direct.reserve(cap);
    }

    size_type size() const noexcept {
        return direct.size();
    }

    bool empty() const noexcept {
        return direct.empty();
    }

    const entity_type * data() const noexcept {
        return direct.data();
    }

    iterator_type begin() const noexcept {
        return Iterator{&direct, direct.size()};
    }

    iterator_type end() const noexcept {
        return Iterator{&direct, 0};
    }

    bool has(entity_type entity) const noexcept {
        using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
        // explicit promotion to avoid warnings with std::uint16_t
        const auto entt = promotion_type{entity} & traits_type::entity_mask;
        // the in-use control bit permits to avoid accessing the direct vector
        return (entt < reverse.size()) && (reverse[entt] & in_use);
    }

    pos_type get(entity_type entity) const noexcept {
        assert(has(entity));
        const auto entt = entity & traits_type::entity_mask;
        // we must get rid of the in-use bit for it's not part of the position
        return reverse[entt] & ~in_use;
    }

    void construct(entity_type entity) {
        assert(!has(entity));
        using promotion_type = std::conditional_t<sizeof(size_type) >= sizeof(entity_type), size_type, entity_type>;
        // explicit promotion to avoid warnings with std::uint16_t
        const auto entt = promotion_type{entity} & traits_type::entity_mask;

        if(!(entt < reverse.size())) {
            reverse.resize(entt+1, pos_type{});
        }

        // we exploit the fact that pos_type is equal to entity_type and pos has
        // traits_type::version_mask bits unused we can use to mark it as in-use
        reverse[entt] = pos_type(direct.size()) | in_use;
        direct.emplace_back(entity);
    }

    virtual void destroy(entity_type entity) {
        assert(has(entity));
        const auto entt = entity & traits_type::entity_mask;
        const auto back = direct.back() & traits_type::entity_mask;
        const auto pos = reverse[entt] & ~in_use;
        // the order matters: if back and entt are the same (for the sparse set
        // has size 1), switching the two lines below doesn't work as expected
        reverse[back] = pos | in_use;
        reverse[entt] = pos;
        // swapping isn't required here, we are getting rid of the last element
        direct[pos] = direct.back();
        direct.pop_back();
    }

    void swap(pos_type lhs, pos_type rhs) noexcept {
        assert(lhs < direct.size());
        assert(rhs < direct.size());
        const auto src = direct[lhs] & traits_type::entity_mask;
        const auto dst = direct[rhs] & traits_type::entity_mask;
        std::swap(reverse[src], reverse[dst]);
        std::swap(direct[lhs], direct[rhs]);
    }

    virtual void respect(const SparseSet<Entity> &other) noexcept {
        auto from = other.begin();
        auto to = other.end();

        pos_type pos = direct.size() - 1;

        while(pos > 0 && from != to) {
            if(has(*from)) {
                if(*from != direct[pos]) {
                    swap(pos, get(*from));
                }

                --pos;
            }

            ++from;
        }
    }

    virtual void reset() {
        reverse.clear();
        direct.clear();
    }

private:
    std::vector<pos_type> reverse;
    std::vector<entity_type> direct;
};


template<typename Entity, typename Type>
class SparseSet<Entity, Type>: public SparseSet<Entity> {
    using underlying_type = SparseSet<Entity>;

public:
    using object_type = Type;
    using entity_type = typename underlying_type::entity_type;
    using pos_type = typename underlying_type::pos_type;
    using size_type = typename underlying_type::size_type;
    using iterator_type = typename underlying_type::iterator_type;

    SparseSet() noexcept = default;

    SparseSet(const SparseSet &) = delete;
    SparseSet(SparseSet &&) = default;

    SparseSet & operator=(const SparseSet &) = delete;
    SparseSet & operator=(SparseSet &&) = default;

    void reserve(size_type cap) {
        underlying_type::reserve(cap);
        instances.reserve(cap);
    }

    const object_type * raw() const noexcept {
        return instances.data();
    }

    object_type * raw() noexcept {
        return instances.data();
    }

    const object_type & get(entity_type entity) const noexcept {
        return instances[underlying_type::get(entity)];
    }

    object_type & get(entity_type entity) noexcept {
        return const_cast<object_type &>(const_cast<const SparseSet *>(this)->get(entity));
    }

    template<typename... Args>
    object_type & construct(entity_type entity, Args&&... args) {
        underlying_type::construct(entity);
        // emplace_back doesn't work well with PODs because of its placement new
        instances.push_back({ std::forward<Args>(args)... });
        return instances.back();
    }

    void destroy(entity_type entity) override {
        // swapping isn't required here, we are getting rid of the last element
        instances[underlying_type::get(entity)] = std::move(instances.back());
        instances.pop_back();
        underlying_type::destroy(entity);
    }

    template<typename Compare>
    void sort(Compare compare) {
        std::vector<pos_type> copy(instances.size());
        std::iota(copy.begin(), copy.end(), 0);

        std::sort(copy.begin(), copy.end(), [this, compare = std::move(compare)](auto lhs, auto rhs) {
            return compare(const_cast<const object_type &>(instances[rhs]), const_cast<const object_type &>(instances[lhs]));
        });

        for(pos_type pos = 0, last = copy.size(); pos < last; ++pos) {
            auto curr = pos;
            auto next = copy[curr];

            while(curr != next) {
                auto lhs = copy[curr];
                auto rhs = copy[next];
                std::swap(instances[lhs], instances[rhs]);
                underlying_type::swap(lhs, rhs);
                copy[curr] = curr;
                curr = next;
                next = copy[curr];
            }
        }
    }

    void respect(const SparseSet<Entity> &other) noexcept override {
        auto from = other.begin();
        auto to = other.end();

        pos_type pos = underlying_type::size() - 1;
        const auto *direct = underlying_type::data();

        while(pos > 0 && from != to) {
            if(underlying_type::has(*from)) {
                if(*from != *(direct + pos)) {
                    auto candidate = underlying_type::get(*from);
                    std::swap(instances[pos], instances[candidate]);
                    underlying_type::swap(pos, candidate);
                }

                --pos;
            }

            ++from;
        }
    }

    void reset() override {
        underlying_type::reset();
        instances.clear();
    }

private:
    std::vector<object_type> instances;
};


}


#endif // ENTT_ENTITY_SPARSE_SET_HPP