now that it's done, remove it

It can always be brought back later.

1 files changed, 0 insertions, 147 deletions

diff --git a/src/entity.hpp b/src/entity.hpp
index 51698651..44f6295a 100644
--- a/src/entity.hpp
+++ b/src/entity.hpp
@@ -4,9 +4,7 @@
 #include <compare>
 #include <type_traits>
 #include <utility>
-#include <algorithm>
 #include <tuple>
-#include <array>
 #include <Corrade/Containers/StringView.h>
 
 namespace floormat {}
@@ -192,151 +190,6 @@ constexpr CORRADE_ALWAYS_INLINE bool find_in_tuple(F&& fun, Tuple&& tuple)
     return false;
 }
 
-template<typename... Ts> struct parameter_pack;
-
-template<template<typename...> class F, typename Acc, typename T, typename... Fs>
-struct reduce0_;
-
-template<template<typename...> class F, typename Acc, template<typename...> class X, typename... Fs>
-struct reduce0_<F, Acc, X<>, Fs...> {
-    using type = Acc;
-};
-
-template<template<typename...> class F, typename Acc, template<typename...> class X, typename T, typename... Ts, typename... Fs>
-struct reduce0_<F, Acc, X<T, Ts...>, Fs...> {
-    using type = typename reduce0_< F, F<Acc, T>, parameter_pack<Ts...>, Fs... >::type;
-};
-
-template<template<typename...> class F, typename Acc, typename X, typename... Fs>
-using reduce0 = typename reduce0_<F, Acc, X, Fs...>::type;
-
-template<template<typename...> class F, typename X, typename... Fs>
-struct reduce_;
-
-template<template<typename...> class F, template<typename...> class X, typename T1, typename... Ts, typename... Fs>
-struct reduce_<F, X<T1, Ts...>, Fs...> {
-    using type = typename reduce0_< F, T1, parameter_pack<Ts...>, Fs... >::type;
-};
-
-template<template<typename...> class F, typename T, typename... Fs>
-using reduce = typename reduce_<F, T, Fs...>::type;
-
-template<typename T, template<typename...> typename C, typename... Args2>
-struct lift_;
-
-template<template<typename...> class C, template<typename...> class T, typename... Args, typename... CArgs>
-struct lift_<T<Args...>, C, CArgs...> {
-    using type = C<CArgs..., Args...>;
-};
-
-template<typename T, template<typename...> class C, typename... CArgs>
-using lift = typename lift_<T, C, CArgs...>::type;
-
-template<template<typename...> class F, template<typename...> class C, typename T, typename... Us>
-struct map_;
-
-template<template<typename...> class F, template<typename...> class C, template<typename...> class X, typename... Ts, typename... Us>
-struct map_<F, C, X<Ts...>, Us...> {
-    using type = C<F<Us..., Ts>...>;
-};
-
-template<template<typename...> class F, typename X, typename... Us>
-using map = typename map_<F, detail::parameter_pack, X, Us...>::type;
-
-template<std::size_t N, typename T>
-struct skip_;
-
-template<std::size_t N, template<typename...> class Tuple, typename T, typename... Ts>
-struct skip_<N, Tuple<T, Ts...>> {
-    using type = typename skip_<N-1, parameter_pack<Ts...>>::type;
-};
-
-template<template<typename...> class Tuple, typename... Ts>
-struct skip_<0, Tuple<Ts...>> { using type = parameter_pack<Ts...>; };
-
-template<template<typename...> class Tuple, typename T, typename... Ts>
-struct skip_<0, Tuple<T, Ts...>> {
-    using type = parameter_pack<T, Ts...>;
-};
-
-template<std::size_t N, typename T>
-using skip = typename skip_<N, T>::type;
-
-template<std::size_t N, typename Acc, typename T>
-struct take_;
-
-template<template<typename...> class Tuple, typename... Ts, typename... As>
-struct take_<0, parameter_pack<As...>, Tuple<Ts...>> {
-    using type = parameter_pack<As...>;
-};
-
-template<typename... As, template<typename...> class Tuple, typename T1, typename... Ts>
-struct take_<0, parameter_pack<As...>, Tuple<T1, Ts...>> {
-    using type = parameter_pack<As...>;
-};
-
-template<std::size_t N, typename... As, template<typename...> class Tuple, typename T1, typename... Ts>
-struct take_<N, parameter_pack<As...>, Tuple<T1, Ts...>> {
-    using type = typename take_<N-1, parameter_pack<As..., T1>, parameter_pack<Ts...>>::type;
-};
-
-template<std::size_t N, typename T>
-using take = typename take_<N, parameter_pack<>, T>::type;
-
-template<std::size_t N, typename T>
-struct nth_;
-
-template<std::size_t N, template<typename...> class X, typename T, typename... Ts>
-struct nth_<N, X<T, Ts...>> {
-    using type = typename nth_<N-1, parameter_pack<Ts...>>::type;
-};
-
-template<template<typename...> class X, typename T, typename... Ts>
-struct nth_<0, X<T, Ts...>> {
-    using type = T;
-};
-
-template<std::size_t N, typename T>
-using nth = typename nth_<N, T>::type;
-
-template<std::size_t N, typename Acc, typename T>
-struct except_nth_;
-
-template<std::size_t N, template<typename...> class X, typename... As, typename T, typename... Ts>
-struct except_nth_<N, parameter_pack<As...>, X<T, Ts...>> {
-    using type = typename except_nth_<N-1, parameter_pack<As..., T>, parameter_pack<Ts...>>::type;
-};
-
-template<typename... As, template<typename...> class X, typename T, typename... Ts>
-struct except_nth_<0, parameter_pack<As...>, X<T, Ts...>> {
-    using type = parameter_pack<As..., Ts...>;
-};
-
-template<std::size_t N, typename T>
-using except_nth = typename except_nth_<N, parameter_pack<>, T>::type;
-
-template<typename Tuple, auto KeyFn, auto Comp>
-struct sort_tuple_ {
-    template<std::size_t... Is>
-    static consteval auto sort_indices(const Tuple& tuple, const std::index_sequence<Is...>&) {
-        std::array<std::size_t, sizeof...(Is)> indices = { Is..., };
-        using KeyT = decltype(KeyFn(std::get<0>(tuple)));
-        std::array<KeyT, sizeof...(Is)> keys = { KeyFn(std::get<Is>(tuple))..., };
-        std::sort(indices.begin(), indices.end(), [&](std::size_t a, std::size_t b) { return Comp(keys[a], keys[b]); });
-        return indices;
-    }
-
-    template<auto Array>
-    struct helper {
-        template<std::size_t... Is>
-        static consteval auto do_sort(const Tuple& tuple, const std::index_sequence<Is...>&) {
-            return std::make_tuple(std::get<Array[Is]>(tuple)...);
-        }
-    };
-};
-
-
-
 } // namespace detail
 
 template<typename F, typename Tuple>