Select.hpp

Go to the documentation of this file.

 
 
#ifndef ECSTASY_QUERY_SELECT_HPP_
#define ECSTASY_QUERY_SELECT_HPP_
 
#include <algorithm>
#include <stddef.h>
#include <tuple>
 
#include "Query.hpp"
#include "util/meta/Traits.hpp"
#include "util/meta/contains.hpp"
#include "util/meta/type_set_eq.hpp"
 
namespace ecstasy::query
{
    template <Queryable... SelectedQueryables>
    struct Select {
      public:
        using SelectedTuple = std::tuple<SelectedQueryables &...>;
 
      private:
        template <Queryable Q>
        [[nodiscard]] constexpr static bool isQueryableSelected() noexcept
        {
            return util::meta::contains<Q, SelectedQueryables...>;
        }
 
        template <typename... Valids>
        struct SorteredTie {
            [[nodiscard]] static constexpr SelectedTuple sort(Valids &...valids) noexcept
            {
                return std::tie(std::forward<Valids &>(valids)...);
            }
 
            template <Queryable Q, Queryable... Qs>
            [[nodiscard]] static constexpr SelectedTuple sort(Valids &...valids, Q &current, Qs &...lefts) noexcept
            {
                if constexpr (std::is_same_v<
                                  typename util::meta::Traits<SelectedQueryables...>::template Nth<sizeof...(Valids)>,
                                  Q>)
                    return SorteredTie<Valids..., Q>::sort(
                        std::forward<Valids &>(valids)..., current, std::forward<Qs &>(lefts)...);
                else
                    return SorteredTie<Valids...>::sort(
                        std::forward<Valids &>(valids)..., std::forward<Qs &>(lefts)..., current);
            }
        };
 
        template <Queryable... Qs>
        [[nodiscard]] constexpr static SelectedTuple tieQueryables(Qs &...queryables) noexcept
        {
            static_assert(util::meta::type_set_eq_v<std::tuple<SelectedQueryables...>, std::tuple<Qs...>>,
                "Missing queryables in where clause");
            if constexpr (std::is_same_v<std::tuple<SelectedQueryables...>, std::tuple<Qs...>>)
                return std::tie(std::forward<Qs &>(queryables)...);
            else
                return SorteredTie<>::template sort(std::forward<Qs &>(queryables)...);
        }
 
        template <bool ContainsPivot, Queryable Pivot, Queryable... Lefts>
        struct FilterQueryables {
            template <Queryable Q>
            [[nodiscard]] constexpr static bool isQueryableRequired() noexcept
            {
                return isQueryableSelected<Q>() && !util::meta::contains<Q, Lefts...>;
            }
 
            [[nodiscard]] constexpr static SelectedTuple value(Lefts &...lefts, Pivot &pivot) noexcept
            {
                if constexpr (ContainsPivot)
                    return tieQueryables(std::forward<Lefts &>(lefts)..., pivot);
                else {
                    (void)pivot;
                    return tieQueryables(std::forward<Lefts &>(lefts)...);
                }
            }
 
            template <Queryable NextPivot, Queryable... Rights>
            [[nodiscard]] constexpr static SelectedTuple value(
                Lefts &...lefts, Pivot &pivot, NextPivot &nextPivot, Rights &...rights) noexcept
            {
                if constexpr (ContainsPivot)
                    return FilterQueryables<isQueryableRequired<NextPivot>(), NextPivot, Lefts..., Pivot>::value(
                        std::forward<Lefts &>(lefts)..., pivot, nextPivot, std::forward<Rights &>(rights)...);
                else {
                    (void)pivot;
                    return FilterQueryables<isQueryableSelected<NextPivot>(), NextPivot, Lefts...>::value(
                        std::forward<Lefts &>(lefts)..., nextPivot, std::forward<Rights &>(rights)...);
                }
            }
        };
 
        template <Queryable... Queryables>
        [[nodiscard]] constexpr static SelectedTuple filterQueryables(Queryables &...queryables) noexcept
        {
            return FilterQueryables<isQueryableSelected<typename util::meta::Traits<Queryables...>::First>(),
                typename util::meta::Traits<Queryables...>::First>::value(std::forward<Queryables &>(queryables)...);
        }
 
      public:
        template <typename Conditions = util::meta::Traits<>, Queryable FirstWhere, Queryable... Wheres>
        static QueryImplementation<util::meta::Traits<SelectedQueryables...>, Conditions> where(
            FirstWhere &firstWhere, Wheres &...wheres)
        {
            if constexpr (is_queryable_with_adjust_v<FirstWhere>
                || std::disjunction_v<is_queryable_with_adjust<Wheres>...>) {
                size_t maxSize = std::max({getQueryableMask(firstWhere).size(), getQueryableMask(wheres).size()...});
 
                adjustMask(firstWhere, maxSize);
                (adjustMask(wheres, maxSize), ...);
            }
 
            util::BitSet mask = (util::BitSet(getQueryableMask(firstWhere)) &= ... &= getQueryableMask(wheres));
 
            return QueryImplementation<util::meta::Traits<SelectedQueryables...>, Conditions>(
                mask, filterQueryables(firstWhere, wheres...));
        }
    };
 
} // namespace ecstasy::query
 
#endif /* !ECSTASY_QUERY_SELECT_HPP_ */