Query.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_QUERY_QUERY_HPP_
#define ECSTASY_QUERY_QUERY_HPP_
 
#include <algorithm>
#include <functional>
#include <thread>
 
#include "concepts/Condition.hpp"
#include "concepts/Queryable.hpp"
#include "concepts/QueryableNeedAdjust.hpp"
#include "conditions/Condition.hpp"
#include "util/BitSet.hpp"
#include "util/meta/Traits.hpp"
#include "util/meta/index.hpp"
 
namespace ecstasy::query
{
    class Entities;
    class IStorage;
 
    // clang-format off
    // clang-format on
    template <typename Storages, typename Conditions = void, bool AutoLock = false>
    class QueryImplementation {};
 
    // clang-format off
    // clang-format on
    template <Queryable First, Queryable... Others, typename... Conditions, bool AutoLock>
    class QueryImplementation<util::meta::Traits<First, Others...>, util::meta::Traits<Conditions...>, AutoLock> {
      public:
        using QueryData = std::tuple<queryable_data_t<First>, queryable_data_t<Others>...>;
        using Queryables =
            std::tuple<queryable_qualifiers_t<First, AutoLock>, queryable_qualifiers_t<Others, AutoLock>...>;
 
        class Iterator {
          public:
            using iterator_category = std::input_iterator_tag;
            using difference_type = std::ptrdiff_t;
            using value_type = QueryData;
            using pointer = value_type *;
            using reference = value_type &;
 
            // All iterators must be constructible, copy-constructible, copy-assignable, destructible and swappable.///
 
            explicit Iterator() noexcept
            {
            }
 
            explicit Iterator(util::BitSet const &mask, Queryables const &storages, std::size_t pos) noexcept(
                sizeof...(Conditions) == 0)
                : _mask(std::cref(mask)), _storages(std::cref(storages)), _pos(pos)
            {
                if constexpr (sizeof...(Conditions) != 0)
                    applyConditions();
            }
 
            Iterator(Iterator const &) noexcept = default;
 
            [[nodiscard]] Iterator &operator=(Iterator const &) noexcept = default;
 
            Iterator(Iterator &&) noexcept = default;
 
            [[nodiscard]] Iterator &operator=(Iterator &&) noexcept = default;
 
            [[nodiscard]] constexpr bool operator==(Iterator const &other) const noexcept
            {
                return this->_pos == other._pos;
            }
 
            [[nodiscard]] constexpr bool operator!=(Iterator const &other) const noexcept
            {
                return this->_pos != other._pos;
            }
 
            [[nodiscard]] value_type operator*() const
            {
                return this->get_components(std::make_index_sequence<(sizeof...(Others)) + 1>());
            }
 
            [[nodiscard]] value_type operator->() const
            {
                return *this;
            }
 
            Iterator &operator++()
            {
                this->_pos = this->_mask.get().firstSet(this->_pos + 1);
                if constexpr (sizeof...(Conditions) != 0)
                    applyConditions();
                return *this;
            }
 
            [[nodiscard]] Iterator operator++(int)
            {
                Iterator result = *this;
 
                return ++result;
            }
 
            [[nodiscard]] constexpr size_t getPosition() const noexcept
            {
                return _pos;
            }
 
          private:
            std::reference_wrapper<const util::BitSet> _mask;
            std::reference_wrapper<const Queryables> _storages;
            std::size_t _pos;
 
            template <QConditionConst Condition>
            bool checkCondition() const
            {
                return Condition::test();
            }
 
            template <QConditionLeft Condition>
            bool checkCondition() const
            {
                static_assert(
                    std::disjunction_v<
                        std::is_same<typename Condition::Left, std::remove_reference_t<queryable_data_t<Others>>>...,
                        std::is_same<typename Condition::Left, std::remove_reference_t<queryable_data_t<First>>>>,
                    "Condition left operand must be included in the queryable types.");
                auto &storage = std::get<
                    util::meta::index_v<typename Condition::Left, std::remove_reference_t<queryable_data_t<First>>,
                        std::remove_reference_t<queryable_data_t<Others>>...>>(_storages.get());
 
                return Condition::test(getQueryableData(storage, _pos));
            }
 
            template <QConditionRight Condition>
            bool checkCondition() const
            {
                static_assert(
                    std::disjunction_v<
                        std::is_same<typename Condition::Right, std::remove_reference_t<queryable_data_t<Others>>>...,
                        std::is_same<typename Condition::Right, std::remove_reference_t<queryable_data_t<First>>>>,
                    "Condition right operand must be included in the queryable types.");
                auto &storage = std::get<
                    util::meta::index_v<typename Condition::Right, std::remove_reference_t<queryable_data_t<First>>,
                        std::remove_reference_t<queryable_data_t<Others>>...>>(_storages.get());
 
                return Condition::test(getQueryableData(storage, _pos));
            }
 
            template <QConditionLeftRight Condition>
            bool checkCondition() const
            {
                static_assert(
                    std::disjunction_v<
                        std::is_same<typename Condition::Left, std::remove_reference_t<queryable_data_t<Others>>>...,
                        std::is_same<typename Condition::Left, std::remove_reference_t<queryable_data_t<First>>>>,
                    "Condition left operand must be included in the queryable types.");
                static_assert(
                    std::disjunction_v<
                        std::is_same<typename Condition::Right, std::remove_reference_t<queryable_data_t<Others>>>...,
                        std::is_same<typename Condition::Right, std::remove_reference_t<queryable_data_t<First>>>>,
                    "Condition right operand must be included in the queryable types.");
                auto &storageLeft = std::get<
                    util::meta::index_v<typename Condition::Left, std::remove_reference_t<queryable_data_t<First>>,
                        std::remove_reference_t<queryable_data_t<Others>>...>>(_storages.get());
                auto &storageRight = std::get<
                    util::meta::index_v<typename Condition::Right, std::remove_reference_t<queryable_data_t<First>>,
                        std::remove_reference_t<queryable_data_t<Others>>...>>(_storages.get());
 
                return Condition::test(getQueryableData(storageLeft, _pos), getQueryableData(storageRight, _pos));
            }
 
            inline void applyConditions()
            {
                if constexpr (sizeof...(Conditions) != 0) {
                    while (this->_pos != this->_mask.get().size() - 1 && !(true & ... & checkCondition<Conditions>()))
                        ++*this;
                }
            }
 
            template <size_t... Indices>
            [[nodiscard]] value_type get_components(std::index_sequence<Indices...>) const
            {
                return {getQueryableData(std::get<Indices>(_storages.get()), _pos)...};
            }
        };
 
        QueryImplementation(util::BitSet &mask, const Queryables &storages) : _mask(mask), _storages(storages)
        {
            // push a sentinel bit at the end.
            this->_mask.push(true);
            this->_begin = this->_mask.firstSet();
        }
 
        QueryImplementation(First &first, Others &...others) : _storages(first, others...)
        {
            if constexpr (is_queryable_with_adjust_v<First>
                || std::disjunction_v<is_queryable_with_adjust<Others>...>) {
                size_t maxSize = std::max({getQueryableMask(first).size(), getQueryableMask(others).size()...});
 
                adjustMask(first, maxSize);
                (adjustMask(others, maxSize), ...);
            }
            this->_mask = (util::BitSet(getQueryableMask(first)) &= ... &= getQueryableMask(others));
 
            // push a sentinel bit at the end.
            this->_mask.push(true);
            this->_begin = this->_mask.firstSet();
        }
 
        [[nodiscard]] Iterator begin() const noexcept
        {
            return Iterator(this->_mask, this->_storages, this->_begin);
        }
 
        [[nodiscard]] Iterator end() const noexcept
        {
            return Iterator(this->_mask, this->_storages, this->_mask.size() - 1);
        }
 
        [[nodiscard]] constexpr const util::BitSet &getMask() const noexcept
        {
            return _mask;
        }
 
        [[nodiscard]] QueryData getQueryData(std::size_t index) const
        {
            return get_components(index, std::make_index_sequence<(sizeof...(Others)) + 1>());
        }
 
        template <typename F>
        void splitThreads(std::size_t batchSize, F &&fct, bool wait = true)
        {
            Iterator end = this->end();
            Iterator current = this->begin();
            Iterator currentBatchStart = current;
            size_t currentBatchSize = 0;
            std::vector<std::thread> threads;
 
            while (current != end) {
                ++currentBatchSize;
                // Find the next element (which may be the end sentinel)
                ++current;
                // Batch full, we start a new thread and reset the current batch informations
                if (currentBatchSize == batchSize) {
                    threads.emplace_back(processBatch<F>, currentBatchStart, current, fct);
                    currentBatchSize = 0;
                    currentBatchStart = current;
                }
            }
 
            if (currentBatchSize > 0)
                threads.emplace_back(processBatch<F>, currentBatchStart, current, fct);
 
            if (wait)
                for (auto &thread : threads)
                    thread.join();
        }
 
      private:
        util::BitSet _mask;
        Queryables _storages;
        size_t _begin;
 
        template <typename F>
        static void processBatch(Iterator start, Iterator end, F &&fct) noexcept(noexcept(fct(*start)))
        {
            for (auto i = start; i != end; ++i)
                fct(*i);
        }
 
        template <size_t... Indices>
        QueryData get_components(std::size_t index, std::index_sequence<Indices...>) const
        {
            return {getQueryableData(std::get<Indices>(_storages), index)...};
        }
    };
 
    template <Queryable First, Queryable... Others>
    class Query : public QueryImplementation<util::meta::Traits<First, Others...>, util::meta::Traits<>> {
      public:
        Query(util::BitSet &mask, const std::tuple<First &, Others &...> &storages)
            : QueryImplementation<util::meta::Traits<First, Others...>, util::meta::Traits<>>(mask, storages)
        {
        }
 
        Query(First &first, Others &...others)
            : QueryImplementation<util::meta::Traits<First, Others...>, util::meta::Traits<>>(
                first, std::forward<Others &>(others)...)
        {
        }
    };
 
    template <Queryable... Qs>
    class ThreadSafeQuery : public QueryImplementation<util::meta::Traits<Qs...>, util::meta::Traits<>, true> {
      public:
        ThreadSafeQuery(util::BitSet &mask, const std::tuple<Qs &...> &storages)
            : QueryImplementation<util::meta::Traits<Qs...>, util::meta::Traits<>, true>(mask, storages)
        {
        }
 
        ThreadSafeQuery(Qs &...others)
            : QueryImplementation<util::meta::Traits<Qs...>, util::meta::Traits<>, true>(std::forward<Qs &>(others)...)
        {
        }
    };
 
} // namespace ecstasy::query
 
#endif /* !QUERY_HPP_ */