sparse_set.hpp

#ifndef ENTT_ENTITY_SPARSE_SET_HPP
#define ENTT_ENTITY_SPARSE_SET_HPP


#include <algorithm>
#include <iterator>
#include <numeric>
#include <utility>
#include <vector>
#include <cstddef>
#include <cassert>
#include <type_traits>
#include "../config/config.h"
#include "../core/algorithm.hpp"
#include "entt_traits.hpp"
#include "entity.hpp"


namespace entt {


template<typename...>
class SparseSet;


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

    class Iterator final {
        friend class SparseSet<Entity>;

        using direct_type = const std::vector<Entity>;
        using index_type = typename traits_type::difference_type;

        Iterator(direct_type *direct, index_type index) ENTT_NOEXCEPT
            : direct{direct}, index{index}
        {}

    public:
        using difference_type = index_type;
        using value_type = const Entity;
        using pointer = value_type *;
        using reference = value_type &;
        using iterator_category = std::random_access_iterator_tag;

        Iterator() ENTT_NOEXCEPT = default;

        Iterator(const Iterator &) ENTT_NOEXCEPT = default;
        Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;

        Iterator & operator++() ENTT_NOEXCEPT {
            return --index, *this;
        }

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

        Iterator & operator--() ENTT_NOEXCEPT {
            return ++index, *this;
        }

        Iterator operator--(int) ENTT_NOEXCEPT {
            Iterator orig = *this;
            return --(*this), orig;
        }

        Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
            index -= value;
            return *this;
        }

        Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
            return Iterator{direct, index-value};
        }

        inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
            return (*this += -value);
        }

        inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
            return (*this + -value);
        }

        difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
            return other.index - index;
        }

        reference operator[](const difference_type value) const ENTT_NOEXCEPT {
            const auto pos = size_type(index-value-1);
            return (*direct)[pos];
        }

        bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
            return other.index == index;
        }

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

        bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
            return index > other.index;
        }

        bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
            return index < other.index;
        }

        inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
            return !(*this > other);
        }

        inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
            return !(*this < other);
        }

        pointer operator->() const ENTT_NOEXCEPT {
            const auto pos = size_type(index-1);
            return &(*direct)[pos];
        }

        inline reference operator*() const ENTT_NOEXCEPT {
            return *operator->();
        }

    private:
        direct_type *direct;
        index_type index;
    };

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

    SparseSet() ENTT_NOEXCEPT = default;

    virtual ~SparseSet() ENTT_NOEXCEPT = default;

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

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

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

    size_type capacity() const ENTT_NOEXCEPT {
        return direct.capacity();
    }

    size_type extent() const ENTT_NOEXCEPT {
        return reverse.size();
    }

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

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

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

    const_iterator_type cbegin() const ENTT_NOEXCEPT {
        const typename traits_type::difference_type pos = direct.size();
        return const_iterator_type{&direct, pos};
    }

    inline const_iterator_type begin() const ENTT_NOEXCEPT {
        return cbegin();
    }

    inline iterator_type begin() ENTT_NOEXCEPT {
        return cbegin();
    }

    const_iterator_type cend() const ENTT_NOEXCEPT {
        return const_iterator_type{&direct, {}};
    }

    inline const_iterator_type end() const ENTT_NOEXCEPT {
        return cend();
    }

    inline iterator_type end() ENTT_NOEXCEPT {
        return cend();
    }

    inline const entity_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
        return cbegin()[pos];
    }

    bool has(const entity_type entity) const ENTT_NOEXCEPT {
        const auto pos = size_type(entity & traits_type::entity_mask);
        // testing against null permits to avoid accessing the direct vector
        return (pos < reverse.size()) && (reverse[pos] != null);
    }

    bool fast(const entity_type entity) const ENTT_NOEXCEPT {
        const auto pos = size_type(entity & traits_type::entity_mask);
        assert(pos < reverse.size());
        // testing against null permits to avoid accessing the direct vector
        return (reverse[pos] != null);
    }

    size_type get(const entity_type entity) const ENTT_NOEXCEPT {
        assert(has(entity));
        const auto pos = size_type(entity & traits_type::entity_mask);
        return size_type(reverse[pos]);
    }

    void construct(const entity_type entity) {
        assert(!has(entity));
        const auto pos = size_type(entity & traits_type::entity_mask);

        if(!(pos < reverse.size())) {
            // null is safe in all cases for our purposes
            reverse.resize(pos+1, null);
        }

        reverse[pos] = entity_type(direct.size());
        direct.push_back(entity);
    }

    virtual void destroy(const entity_type entity) {
        assert(has(entity));
        const auto back = direct.back();
        auto &candidate = reverse[size_type(entity & traits_type::entity_mask)];
        // swapping isn't required here, we are getting rid of the last element
        reverse[back & traits_type::entity_mask] = candidate;
        direct[size_type(candidate)] = back;
        candidate = null;
        direct.pop_back();
    }

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

    void respect(const SparseSet<Entity> &other) ENTT_NOEXCEPT {
        auto from = other.cbegin();
        auto to = other.cend();

        size_type pos = direct.size() - 1;

        while(pos && 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<entity_type> reverse;
    std::vector<entity_type> direct;
};


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

    template<bool Const>
    class Iterator final {
        friend class SparseSet<Entity, Type>;

        using instance_type = std::conditional_t<Const, const std::vector<Type>, std::vector<Type>>;
        using index_type = typename traits_type::difference_type;

        Iterator(instance_type *instances, index_type index) ENTT_NOEXCEPT
            : instances{instances}, index{index}
        {}

    public:
        using difference_type = index_type;
        using value_type = std::conditional_t<Const, const Type, Type>;
        using pointer = value_type *;
        using reference = value_type &;
        using iterator_category = std::random_access_iterator_tag;

        Iterator() ENTT_NOEXCEPT = default;

        Iterator(const Iterator &) ENTT_NOEXCEPT = default;
        Iterator & operator=(const Iterator &) ENTT_NOEXCEPT = default;

        Iterator & operator++() ENTT_NOEXCEPT {
            return --index, *this;
        }

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

        Iterator & operator--() ENTT_NOEXCEPT {
            return ++index, *this;
        }

        Iterator operator--(int) ENTT_NOEXCEPT {
            Iterator orig = *this;
            return --(*this), orig;
        }

        Iterator & operator+=(const difference_type value) ENTT_NOEXCEPT {
            index -= value;
            return *this;
        }

        Iterator operator+(const difference_type value) const ENTT_NOEXCEPT {
            return Iterator{instances, index-value};
        }

        inline Iterator & operator-=(const difference_type value) ENTT_NOEXCEPT {
            return (*this += -value);
        }

        inline Iterator operator-(const difference_type value) const ENTT_NOEXCEPT {
            return (*this + -value);
        }

        difference_type operator-(const Iterator &other) const ENTT_NOEXCEPT {
            return other.index - index;
        }

        reference operator[](const difference_type value) const ENTT_NOEXCEPT {
            const auto pos = size_type(index-value-1);
            return (*instances)[pos];
        }

        bool operator==(const Iterator &other) const ENTT_NOEXCEPT {
            return other.index == index;
        }

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

        bool operator<(const Iterator &other) const ENTT_NOEXCEPT {
            return index > other.index;
        }

        bool operator>(const Iterator &other) const ENTT_NOEXCEPT {
            return index < other.index;
        }

        inline bool operator<=(const Iterator &other) const ENTT_NOEXCEPT {
            return !(*this > other);
        }

        inline bool operator>=(const Iterator &other) const ENTT_NOEXCEPT {
            return !(*this < other);
        }

        pointer operator->() const ENTT_NOEXCEPT {
            const auto pos = size_type(index-1);
            return &(*instances)[pos];
        }

        inline reference operator*() const ENTT_NOEXCEPT {
            return *operator->();
        }

    private:
        instance_type *instances;
        index_type index;
    };

public:
    using object_type = Type;
    using entity_type = typename underlying_type::entity_type;
    using size_type = typename underlying_type::size_type;
    using iterator_type = Iterator<false>;
    using const_iterator_type = Iterator<true>;

    SparseSet() ENTT_NOEXCEPT = default;

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

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

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

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

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

    const_iterator_type cbegin() const ENTT_NOEXCEPT {
        const typename traits_type::difference_type pos = instances.size();
        return const_iterator_type{&instances, pos};
    }

    inline const_iterator_type begin() const ENTT_NOEXCEPT {
        return cbegin();
    }

    iterator_type begin() ENTT_NOEXCEPT {
        const typename traits_type::difference_type pos = instances.size();
        return iterator_type{&instances, pos};
    }

    const_iterator_type cend() const ENTT_NOEXCEPT {
        return const_iterator_type{&instances, {}};
    }

    inline const_iterator_type end() const ENTT_NOEXCEPT {
        return cend();
    }

    iterator_type end() ENTT_NOEXCEPT {
        return iterator_type{&instances, {}};
    }

    inline const object_type & operator[](const size_type pos) const ENTT_NOEXCEPT {
        return cbegin()[pos];
    }

    inline object_type & operator[](const size_type pos) ENTT_NOEXCEPT {
        return const_cast<object_type &>(const_cast<const SparseSet *>(this)->operator[](pos));
    }

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

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

    template<typename... Args>
    std::enable_if_t<std::is_constructible<Type, Args...>::value, object_type &>
    construct(const entity_type entity, Args &&... args) {
        underlying_type::construct(entity);
        instances.emplace_back(std::forward<Args>(args)...);
        return instances.back();
    }

    template<typename... Args>
    std::enable_if_t<!std::is_constructible<Type, Args...>::value, object_type &>
    construct(const entity_type entity, Args &&... args) {
        underlying_type::construct(entity);
        instances.emplace_back(Type{std::forward<Args>(args)...});
        return instances.back();
    }

    void destroy(const entity_type entity) override {
        // swapping isn't required here, we are getting rid of the last element
        // however, we must protect ourselves from self assignments (see #37)
        auto tmp = std::move(instances.back());
        instances[underlying_type::get(entity)] = std::move(tmp);
        instances.pop_back();
        underlying_type::destroy(entity);
    }

    template<typename Compare, typename Sort = StdSort, typename... Args>
    void sort(Compare compare, Sort sort = Sort{}, Args &&... args) {
        std::vector<size_type> copy(instances.size());
        std::iota(copy.begin(), copy.end(), 0);

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

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

            while(curr != next) {
                const auto lhs = copy[curr];
                const 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) ENTT_NOEXCEPT {
        auto from = other.cbegin();
        auto to = other.cend();

        size_type pos = underlying_type::size() - 1;
        const auto *local = underlying_type::data();

        while(pos && from != to) {
            const auto curr = *from;

            if(underlying_type::has(curr)) {
                if(curr != *(local + pos)) {
                    auto candidate = underlying_type::get(curr);
                    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