group.hpp

#ifndef ENTT_ENTITY_GROUP_HPP
#define ENTT_ENTITY_GROUP_HPP
 
#include <tuple>
#include <type_traits>
#include <utility>
#include "../config/config.h"
#include "../core/iterator.hpp"
#include "../core/type_traits.hpp"
#include "component.hpp"
#include "entity.hpp"
#include "fwd.hpp"
#include "sparse_set.hpp"
#include "storage.hpp"
#include "utility.hpp"
 
namespace entt {
 
template<typename, typename, typename, typename>
class basic_group;
 
template<typename Entity, typename... Get, typename... Exclude>
class basic_group<Entity, owned_t<>, get_t<Get...>, exclude_t<Exclude...>> {
    friend class basic_registry<Entity>;
 
    template<typename Comp>
    using storage_type = constness_as_t<typename storage_traits<Entity, std::remove_const_t<Comp>>::storage_type, Comp>;
 
    using basic_common_type = std::common_type_t<typename storage_type<Get>::base_type...>;
 
    struct extended_group_iterator final {
        using difference_type = std::ptrdiff_t;
        using value_type = decltype(std::tuple_cat(std::tuple<Entity>{}, std::declval<basic_group>().get({})));
        using pointer = input_iterator_pointer<value_type>;
        using reference = value_type;
        using iterator_category = std::input_iterator_tag;
 
        extended_group_iterator() = default;
 
        extended_group_iterator(typename basic_common_type::iterator from, const std::tuple<storage_type<Get> *...> &args)
            : it{from},
              pools{args} {}
 
        extended_group_iterator &operator++() ENTT_NOEXCEPT {
            return ++it, *this;
        }
 
        extended_group_iterator operator++(int) ENTT_NOEXCEPT {
            extended_group_iterator orig = *this;
            return ++(*this), orig;
        }
 
        [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
            const auto entt = *it;
            return std::tuple_cat(std::make_tuple(entt), std::get<storage_type<Get> *>(pools)->get_as_tuple(entt)...);
        }
 
        [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
            return operator*();
        }
 
        [[nodiscard]] bool operator==(const extended_group_iterator &other) const ENTT_NOEXCEPT {
            return other.it == it;
        }
 
        [[nodiscard]] bool operator!=(const extended_group_iterator &other) const ENTT_NOEXCEPT {
            return !(*this == other);
        }
 
    private:
        typename basic_common_type::iterator it;
        std::tuple<storage_type<Get> *...> pools;
    };
 
    basic_group(basic_common_type &ref, storage_type<Get> &...gpool) ENTT_NOEXCEPT
        : handler{&ref},
          pools{&gpool...} {}
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using base_type = basic_common_type;
    using iterator = typename base_type::iterator;
    using reverse_iterator = typename base_type::reverse_iterator;
    using iterable = iterable_adaptor<extended_group_iterator>;
 
    basic_group() ENTT_NOEXCEPT
        : handler{} {}
 
    const base_type &handle() const ENTT_NOEXCEPT {
        return *handler;
    }
 
    template<typename Comp>
    [[nodiscard]] decltype(auto) storage() const ENTT_NOEXCEPT {
        return *std::get<storage_type<Comp> *>(pools);
    }
 
    template<std::size_t Comp>
    [[nodiscard]] decltype(auto) storage() const ENTT_NOEXCEPT {
        return *std::get<Comp>(pools);
    }
 
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return *this ? handler->size() : size_type{};
    }
 
    [[nodiscard]] size_type capacity() const ENTT_NOEXCEPT {
        return *this ? handler->capacity() : size_type{};
    }
 
    void shrink_to_fit() {
        if(*this) {
            handler->shrink_to_fit();
        }
    }
 
    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
        return !*this || handler->empty();
    }
 
    [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
        return *this ? handler->begin() : iterator{};
    }
 
    [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
        return *this ? handler->end() : iterator{};
    }
 
    [[nodiscard]] reverse_iterator rbegin() const ENTT_NOEXCEPT {
        return *this ? handler->rbegin() : reverse_iterator{};
    }
 
    [[nodiscard]] reverse_iterator rend() const ENTT_NOEXCEPT {
        return *this ? handler->rend() : reverse_iterator{};
    }
 
    [[nodiscard]] entity_type front() const ENTT_NOEXCEPT {
        const auto it = begin();
        return it != end() ? *it : null;
    }
 
    [[nodiscard]] entity_type back() const ENTT_NOEXCEPT {
        const auto it = rbegin();
        return it != rend() ? *it : null;
    }
 
    [[nodiscard]] iterator find(const entity_type entt) const ENTT_NOEXCEPT {
        const auto it = *this ? handler->find(entt) : iterator{};
        return it != end() && *it == entt ? it : end();
    }
 
    [[nodiscard]] entity_type operator[](const size_type pos) const {
        return begin()[pos];
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return handler != nullptr;
    }
 
    [[nodiscard]] bool contains(const entity_type entt) const ENTT_NOEXCEPT {
        return *this && handler->contains(entt);
    }
 
    template<typename... Comp>
    [[nodiscard]] decltype(auto) get(const entity_type entt) const {
        ENTT_ASSERT(contains(entt), "Group does not contain entity");
 
        if constexpr(sizeof...(Comp) == 0) {
            return std::tuple_cat(std::get<storage_type<Get> *>(pools)->get_as_tuple(entt)...);
        } else if constexpr(sizeof...(Comp) == 1) {
            return (std::get<storage_type<Comp> *>(pools)->get(entt), ...);
        } else {
            return std::tuple_cat(std::get<storage_type<Comp> *>(pools)->get_as_tuple(entt)...);
        }
    }
 
    template<typename Func>
    void each(Func func) const {
        for(const auto entt: *this) {
            if constexpr(is_applicable_v<Func, decltype(std::tuple_cat(std::tuple<entity_type>{}, std::declval<basic_group>().get({})))>) {
                std::apply(func, std::tuple_cat(std::make_tuple(entt), get(entt)));
            } else {
                std::apply(func, get(entt));
            }
        }
    }
 
    [[nodiscard]] iterable each() const ENTT_NOEXCEPT {
        return handler ? iterable{extended_group_iterator{handler->begin(), pools}, extended_group_iterator{handler->end(), pools}}
                       : iterable{extended_group_iterator{{}, pools}, extended_group_iterator{{}, pools}};
    }
 
    template<typename... Comp, typename Compare, typename Sort = std_sort, typename... Args>
    void sort(Compare compare, Sort algo = Sort{}, Args &&...args) {
        if(*this) {
            if constexpr(sizeof...(Comp) == 0) {
                static_assert(std::is_invocable_v<Compare, const entity_type, const entity_type>, "Invalid comparison function");
                handler->sort(std::move(compare), std::move(algo), std::forward<Args>(args)...);
            } else {
                auto comp = [this, &compare](const entity_type lhs, const entity_type rhs) {
                    if constexpr(sizeof...(Comp) == 1) {
                        return compare((std::get<storage_type<Comp> *>(pools)->get(lhs), ...), (std::get<storage_type<Comp> *>(pools)->get(rhs), ...));
                    } else {
                        return compare(std::forward_as_tuple(std::get<storage_type<Comp> *>(pools)->get(lhs)...), std::forward_as_tuple(std::get<storage_type<Comp> *>(pools)->get(rhs)...));
                    }
                };
 
                handler->sort(std::move(comp), std::move(algo), std::forward<Args>(args)...);
            }
        }
    }
 
    template<typename Comp>
    void sort() const {
        if(*this) {
            handler->respect(*std::get<storage_type<Comp> *>(pools));
        }
    }
 
private:
    base_type *const handler;
    const std::tuple<storage_type<Get> *...> pools;
};
 
template<typename Entity, typename... Owned, typename... Get, typename... Exclude>
class basic_group<Entity, owned_t<Owned...>, get_t<Get...>, exclude_t<Exclude...>> {
    friend class basic_registry<Entity>;
 
    template<typename Comp>
    using storage_type = constness_as_t<typename storage_traits<Entity, std::remove_const_t<Comp>>::storage_type, Comp>;
 
    using basic_common_type = std::common_type_t<typename storage_type<Owned>::base_type..., typename storage_type<Get>::base_type...>;
 
    class extended_group_iterator final {
        template<typename Type>
        auto index_to_element(storage_type<Type> &cpool) const {
            if constexpr(ignore_as_empty_v<std::remove_const_t<Type>>) {
                return std::make_tuple();
            } else {
                return std::forward_as_tuple(cpool.rbegin()[it.index()]);
            }
        }
 
    public:
        using difference_type = std::ptrdiff_t;
        using value_type = decltype(std::tuple_cat(std::tuple<Entity>{}, std::declval<basic_group>().get({})));
        using pointer = input_iterator_pointer<value_type>;
        using reference = value_type;
        using iterator_category = std::input_iterator_tag;
 
        extended_group_iterator() = default;
 
        template<typename... Other>
        extended_group_iterator(typename basic_common_type::iterator from, const std::tuple<storage_type<Owned> *..., storage_type<Get> *...> &cpools)
            : it{from},
              pools{cpools} {}
 
        extended_group_iterator &operator++() ENTT_NOEXCEPT {
            return ++it, *this;
        }
 
        extended_group_iterator operator++(int) ENTT_NOEXCEPT {
            extended_group_iterator orig = *this;
            return ++(*this), orig;
        }
 
        [[nodiscard]] reference operator*() const ENTT_NOEXCEPT {
            return std::tuple_cat(
                std::make_tuple(*it),
                index_to_element<Owned>(*std::get<storage_type<Owned> *>(pools))...,
                std::get<storage_type<Get> *>(pools)->get_as_tuple(*it)...);
        }
 
        [[nodiscard]] pointer operator->() const ENTT_NOEXCEPT {
            return operator*();
        }
 
        [[nodiscard]] bool operator==(const extended_group_iterator &other) const ENTT_NOEXCEPT {
            return other.it == it;
        }
 
        [[nodiscard]] bool operator!=(const extended_group_iterator &other) const ENTT_NOEXCEPT {
            return !(*this == other);
        }
 
    private:
        typename basic_common_type::iterator it;
        std::tuple<storage_type<Owned> *..., storage_type<Get> *...> pools;
    };
 
    basic_group(const std::size_t &extent, storage_type<Owned> &...opool, storage_type<Get> &...gpool) ENTT_NOEXCEPT
        : pools{&opool..., &gpool...},
          length{&extent} {}
 
public:
    using entity_type = Entity;
    using size_type = std::size_t;
    using base_type = basic_common_type;
    using iterator = typename base_type::iterator;
    using reverse_iterator = typename base_type::reverse_iterator;
    using iterable = iterable_adaptor<extended_group_iterator>;
 
    basic_group() ENTT_NOEXCEPT
        : length{} {}
 
    template<typename Comp>
    [[nodiscard]] decltype(auto) storage() const ENTT_NOEXCEPT {
        return *std::get<storage_type<Comp> *>(pools);
    }
 
    template<std::size_t Comp>
    [[nodiscard]] decltype(auto) storage() const ENTT_NOEXCEPT {
        return *std::get<Comp>(pools);
    }
 
    [[nodiscard]] size_type size() const ENTT_NOEXCEPT {
        return *this ? *length : size_type{};
    }
 
    [[nodiscard]] bool empty() const ENTT_NOEXCEPT {
        return !*this || !*length;
    }
 
    [[nodiscard]] iterator begin() const ENTT_NOEXCEPT {
        return *this ? (std::get<0>(pools)->base_type::end() - *length) : iterator{};
    }
 
    [[nodiscard]] iterator end() const ENTT_NOEXCEPT {
        return *this ? std::get<0>(pools)->base_type::end() : iterator{};
    }
 
    [[nodiscard]] reverse_iterator rbegin() const ENTT_NOEXCEPT {
        return *this ? std::get<0>(pools)->base_type::rbegin() : reverse_iterator{};
    }
 
    [[nodiscard]] reverse_iterator rend() const ENTT_NOEXCEPT {
        return *this ? (std::get<0>(pools)->base_type::rbegin() + *length) : reverse_iterator{};
    }
 
    [[nodiscard]] entity_type front() const ENTT_NOEXCEPT {
        const auto it = begin();
        return it != end() ? *it : null;
    }
 
    [[nodiscard]] entity_type back() const ENTT_NOEXCEPT {
        const auto it = rbegin();
        return it != rend() ? *it : null;
    }
 
    [[nodiscard]] iterator find(const entity_type entt) const ENTT_NOEXCEPT {
        const auto it = *this ? std::get<0>(pools)->find(entt) : iterator{};
        return it != end() && it >= begin() && *it == entt ? it : end();
    }
 
    [[nodiscard]] entity_type operator[](const size_type pos) const {
        return begin()[pos];
    }
 
    [[nodiscard]] explicit operator bool() const ENTT_NOEXCEPT {
        return length != nullptr;
    }
 
    [[nodiscard]] bool contains(const entity_type entt) const ENTT_NOEXCEPT {
        return *this && std::get<0>(pools)->contains(entt) && (std::get<0>(pools)->index(entt) < (*length));
    }
 
    template<typename... Comp>
    [[nodiscard]] decltype(auto) get(const entity_type entt) const {
        ENTT_ASSERT(contains(entt), "Group does not contain entity");
 
        if constexpr(sizeof...(Comp) == 0) {
            return std::tuple_cat(std::get<storage_type<Owned> *>(pools)->get_as_tuple(entt)..., std::get<storage_type<Get> *>(pools)->get_as_tuple(entt)...);
        } else if constexpr(sizeof...(Comp) == 1) {
            return (std::get<storage_type<Comp> *>(pools)->get(entt), ...);
        } else {
            return std::tuple_cat(std::get<storage_type<Comp> *>(pools)->get_as_tuple(entt)...);
        }
    }
 
    template<typename Func>
    void each(Func func) const {
        for(auto args: each()) {
            if constexpr(is_applicable_v<Func, decltype(std::tuple_cat(std::tuple<entity_type>{}, std::declval<basic_group>().get({})))>) {
                std::apply(func, args);
            } else {
                std::apply([&func](auto, auto &&...less) { func(std::forward<decltype(less)>(less)...); }, args);
            }
        }
    }
 
    [[nodiscard]] iterable each() const ENTT_NOEXCEPT {
        iterator last = length ? std::get<0>(pools)->basic_common_type::end() : iterator{};
        return {extended_group_iterator{last - *length, pools}, extended_group_iterator{last, pools}};
    }
 
    template<typename... Comp, typename Compare, typename Sort = std_sort, typename... Args>
    void sort(Compare compare, Sort algo = Sort{}, Args &&...args) const {
        auto *cpool = std::get<0>(pools);
 
        if constexpr(sizeof...(Comp) == 0) {
            static_assert(std::is_invocable_v<Compare, const entity_type, const entity_type>, "Invalid comparison function");
            cpool->sort_n(*length, std::move(compare), std::move(algo), std::forward<Args>(args)...);
        } else {
            auto comp = [this, &compare](const entity_type lhs, const entity_type rhs) {
                if constexpr(sizeof...(Comp) == 1) {
                    return compare((std::get<storage_type<Comp> *>(pools)->get(lhs), ...), (std::get<storage_type<Comp> *>(pools)->get(rhs), ...));
                } else {
                    return compare(std::forward_as_tuple(std::get<storage_type<Comp> *>(pools)->get(lhs)...), std::forward_as_tuple(std::get<storage_type<Comp> *>(pools)->get(rhs)...));
                }
            };
 
            cpool->sort_n(*length, std::move(comp), std::move(algo), std::forward<Args>(args)...);
        }
 
        [this](auto *head, auto *...other) {
            for(auto next = *length; next; --next) {
                const auto pos = next - 1;
                [[maybe_unused]] const auto entt = head->data()[pos];
                (other->swap_elements(other->data()[pos], entt), ...);
            }
        }(std::get<storage_type<Owned> *>(pools)...);
    }
 
private:
    const std::tuple<storage_type<Owned> *..., storage_type<Get> *...> pools;
    const size_type *const length;
};
 
} // namespace entt
 
#endif