Predicate.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Foundation/Container/Tuple.hpp"
 
#include <utility>
 
namespace CeresEngine {
 
    template<typename T> struct Predicate {};
 
    template<typename T, typename Predicate1, typename Predicate2> struct BinaryPredicate : Predicate<T> {
        Predicate1 predicate1;
 
        Predicate2 predicate2;
 
        inline constexpr BinaryPredicate(Predicate1&& predicate1, Predicate2&& predicate2) noexcept
                : predicate1(std::forward<Predicate1>(predicate1)), predicate2(std::forward<Predicate2>(predicate2)) {}
    };
 
    template<typename T, typename TPredicate> struct UnaryPredicate : Predicate<T> {
        TPredicate predicate;
 
        explicit inline constexpr UnaryPredicate(TPredicate&& predicate) noexcept : predicate(std::forward<TPredicate>(predicate)) {}
    };
 
    template<typename Predicate1, typename Predicate2, typename... Predicates>
    struct AndPredicate : Predicate<AndPredicate<Predicate1, Predicate2, Predicates...>> {
        Tuple<Predicate1, Predicate2, Predicates...> predicates;
 
        inline constexpr AndPredicate(Predicate1&& predicate1, Predicate2&& predicate2, Predicates&&... predicates) noexcept
                : predicates(std::forward<Predicate1>(predicate1), std::forward<Predicate2>(predicate2), std::forward<Predicates>(predicates)...) {}
 
        template<typename... Input> [[nodiscard]] inline constexpr bool operator()(Input&&... input) const { return impl<0>(input...); }
 
    private:
        template<size_t N, typename... Input> inline constexpr bool impl(Input&... input) const {
            if constexpr(N > sizeof...(Predicates)) {
                return predicates.template get<N>()(input...);
            } else {
                return predicates.template get<N>()(input...) && impl<N + 1>(input...);
            }
        }
    };
 
    template<typename Predicate1, typename Predicate2>
    struct AndPredicate<Predicate1, Predicate2> : BinaryPredicate<AndPredicate<Predicate1, Predicate2>, Predicate1, Predicate2> {
        using BinaryPredicate<AndPredicate<Predicate1, Predicate2>, Predicate1, Predicate2>::BinaryPredicate;
 
        template<typename... Input>
        [[nodiscard]] inline constexpr bool operator()(Input&&... input) const
            noexcept(noexcept(((AndPredicate::predicate1(input...)) && (AndPredicate::predicate2(input...))))) {
            return (this->predicate1(input...)) && (this->predicate2(input...));
        }
    };
 
    template<typename Predicate1, typename Predicate2, typename Predicate3>
    struct AndPredicate<Predicate1, AndPredicate<Predicate2, Predicate3>> : AndPredicate<Predicate1, Predicate2, Predicate3> {
        inline constexpr AndPredicate(Predicate1&& predicate1, AndPredicate<Predicate2, Predicate3>&& predicate2) noexcept
                : AndPredicate<Predicate1, Predicate2, Predicate3>(std::forward<Predicate1>(predicate1), std::forward<Predicate2>(predicate2.predicate1),
                      std::forward<Predicate3>(predicate2.predicate2)) {}
    };
 
    template<typename Predicate1, typename Predicate2, typename Predicate3>
    struct AndPredicate<AndPredicate<Predicate1, Predicate2>, Predicate3> : AndPredicate<Predicate1, Predicate2, Predicate3> {
        inline constexpr AndPredicate(AndPredicate<Predicate1, Predicate2>&& predicate1, Predicate3&& predicate2) noexcept
                : AndPredicate<Predicate1, Predicate2, Predicate3>(std::forward<Predicate1>(predicate1.predicate1),
                      std::forward<Predicate2>(predicate1.predicate2), std::forward<Predicate3>(predicate2)) {}
    };
 
    template<typename Predicate1, typename Predicate2, typename Predicate3, typename Predicate4>
    struct AndPredicate<AndPredicate<Predicate1, Predicate2>, AndPredicate<Predicate3, Predicate4>>
            : AndPredicate<Predicate1, Predicate2, Predicate3, Predicate4> {
        inline constexpr AndPredicate(AndPredicate<Predicate1, Predicate2>&& predicate1, AndPredicate<Predicate3, Predicate4>&& predicate2) noexcept
                : AndPredicate<Predicate1, Predicate2, Predicate3, Predicate4>(std::forward<Predicate1>(predicate1.predicate1),
                      std::forward<Predicate2>(predicate1.predicate2), std::forward<Predicate3>(predicate2.predicate1),
                      std::forward<Predicate3>(predicate2.predicate2)) {}
    };
 
    template<typename Predicate1, typename Predicate2, typename... Predicates>
    struct OrPredicate : Predicate<OrPredicate<Predicate1, Predicate2, Predicates...>> {
        Tuple<Predicate1, Predicate2, Predicates...> predicates;
 
        inline constexpr OrPredicate(Predicate1&& predicate1, Predicate2&& predicate2, Predicates&&... predicates) noexcept
                : predicates(std::forward<Predicate1>(predicate1), std::forward<Predicate2>(predicate2), std::forward<Predicates>(predicates)...) {}
 
        template<typename... Input> [[nodiscard]] inline constexpr bool operator()(Input&&... input) const { return impl<0>(input...); }
 
    private:
        template<size_t N, typename... Input> [[nodiscard]] inline constexpr bool impl(Input&... input) const {
            if constexpr(N > sizeof...(Predicates)) {
                return predicates.template get<N>()(input...);
            } else {
                return predicates.template get<N>()(input...) || impl<N + 1>(input...);
            }
        }
    };
 
    template<typename Predicate1, typename Predicate2>
    struct OrPredicate<Predicate1, Predicate2> : BinaryPredicate<OrPredicate<Predicate1, Predicate2>, Predicate1, Predicate2> {
        using BinaryPredicate<OrPredicate<Predicate1, Predicate2>, Predicate1, Predicate2>::BinaryPredicate;
 
        template<typename... Input>
        [[nodiscard]] inline constexpr bool operator()(Input&&... input) const
            noexcept(noexcept((OrPredicate::predicate1(input...)) || (OrPredicate::predicate2(input...)))) {
            return (this->predicate1(input...)) || (this->predicate2(input...));
        }
    };
 
    template<typename Predicate1, typename Predicate2, typename Predicate3>
    struct OrPredicate<Predicate1, OrPredicate<Predicate2, Predicate3>> : OrPredicate<Predicate1, Predicate2, Predicate3> {
        inline constexpr OrPredicate(Predicate1&& predicate1, OrPredicate<Predicate2, Predicate3>&& predicate2) noexcept
                : OrPredicate<Predicate1, Predicate2, Predicate3>(std::forward<Predicate1>(predicate1), std::forward<Predicate2>(predicate2.predicate1),
                      std::forward<Predicate3>(predicate2.predicate2)) {}
    };
 
    template<typename Predicate1, typename Predicate2, typename Predicate3>
    struct OrPredicate<OrPredicate<Predicate1, Predicate2>, Predicate3> : OrPredicate<Predicate1, Predicate2, Predicate3> {
        inline constexpr OrPredicate(OrPredicate<Predicate1, Predicate2>&& predicate1, Predicate3&& predicate2) noexcept
                : OrPredicate<Predicate1, Predicate2, Predicate3>(std::forward<Predicate1>(predicate1.predicate1),
                      std::forward<Predicate2>(predicate1.predicate2), std::forward<Predicate3>(predicate2)) {}
    };
 
    template<typename Predicate1, typename Predicate2, typename Predicate3, typename Predicate4>
    struct OrPredicate<OrPredicate<Predicate1, Predicate2>, OrPredicate<Predicate3, Predicate4>> : OrPredicate<Predicate1, Predicate2, Predicate3, Predicate4> {
        inline constexpr OrPredicate(OrPredicate<Predicate1, Predicate2>&& predicate1, OrPredicate<Predicate3, Predicate4>&& predicate2) noexcept
                : OrPredicate<Predicate1, Predicate2, Predicate3, Predicate4>(std::forward<Predicate1>(predicate1.predicate1),
                      std::forward<Predicate2>(predicate1.predicate2), std::forward<Predicate3>(predicate2.predicate1),
                      std::forward<Predicate3>(predicate2.predicate2)) {}
    };
 
    template<typename TPredicate> struct NotPredicate : UnaryPredicate<NotPredicate<TPredicate>, TPredicate> {
        using UnaryPredicate<NotPredicate<TPredicate>, TPredicate>::UnaryPredicate;
 
        template<typename... Input>
        [[nodiscard]] inline constexpr bool operator()(Input&&... input) const noexcept(noexcept(NotPredicate::predicate(std::forward<Input>(input)...))) {
            return !(this->predicate(std::forward<Input>(input)...));
        }
    };
 
    template<typename Callable> struct UserPredicate : Predicate<UserPredicate<Callable>> {
        Callable callable;
 
        explicit constexpr UserPredicate(Callable&& callable) noexcept : callable(std::forward<Callable>(callable)) {}
 
        template<typename... Input>
        [[nodiscard]] inline constexpr bool operator()(Input&&... input) const noexcept(noexcept(callable(std::forward<Input>(input)...))) {
            return callable(std::forward<Input>(input)...);
        }
    };
 
    template<typename Predicate1, typename Predicate2>
    struct AndPredicate<NotPredicate<Predicate1>, NotPredicate<Predicate2>> : NotPredicate<OrPredicate<Predicate1, Predicate2>> {
        inline constexpr AndPredicate(NotPredicate<Predicate1>&& predicate1, NotPredicate<Predicate2>&& predicate2) noexcept
                : NotPredicate<OrPredicate<Predicate1, Predicate2>>(
                      OrPredicate<Predicate1, Predicate2>(std::forward<Predicate1>(predicate1.predicate), std::forward<Predicate2>(predicate2.predicate))) {}
    };
 
    template<typename Predicate1, typename Predicate2>
    struct OrPredicate<NotPredicate<Predicate1>, NotPredicate<Predicate2>> : NotPredicate<AndPredicate<Predicate1, Predicate2>> {
        inline constexpr OrPredicate(NotPredicate<Predicate1>&& predicate1, NotPredicate<Predicate2>&& predicate2) noexcept
                : NotPredicate<AndPredicate<Predicate1, Predicate2>>(
                      AndPredicate<Predicate1, Predicate2>(std::forward<Predicate1>(predicate1.predicate), std::forward<Predicate2>(predicate2.predicate))) {}
    };
 
    template<typename TPredicate> struct NotPredicate<NotPredicate<TPredicate>> : TPredicate {
        explicit inline constexpr NotPredicate(NotPredicate<TPredicate>&& predicate) : TPredicate(predicate.predicate) {}
    };
 
    template<typename Predicate1, typename Predicate2>
    inline constexpr auto operator&&(const Predicate<Predicate1>& predicate1, const Predicate<Predicate2>& predicate2) noexcept {
        return AndPredicate<Predicate1, Predicate2>(Predicate1(static_cast<const Predicate1&>(predicate1)),
            Predicate2(static_cast<const Predicate2&>(predicate2)));
    }
 
    template<typename Predicate1, typename Predicate2>
    inline constexpr auto operator&&(Predicate<Predicate1>&& predicate1, Predicate<Predicate2>&& predicate2) noexcept {
        return AndPredicate<Predicate1, Predicate2>(std::forward<Predicate1>(static_cast<Predicate1&&>(predicate1)),
            std::forward<Predicate2>(static_cast<Predicate2&&>(predicate2)));
    }
 
    template<typename Predicate1, typename Predicate2>
    inline constexpr auto operator||(const Predicate<Predicate1>& predicate1, const Predicate<Predicate2>& predicate2) noexcept {
        return OrPredicate<Predicate1, Predicate2>(Predicate1(static_cast<const Predicate1&>(predicate1)),
            Predicate2(static_cast<const Predicate2&>(predicate2)));
    }
 
    template<typename Predicate1, typename Predicate2>
    inline constexpr auto operator||(Predicate<Predicate1>&& predicate1, Predicate<Predicate2>&& predicate2) noexcept {
        return OrPredicate<Predicate1, Predicate2>(std::forward<Predicate1>(static_cast<Predicate1&&>(predicate1)),
            std::forward<Predicate2>(static_cast<Predicate2&&>(predicate2)));
    }
 
    template<typename TPredicate> inline constexpr auto operator!(const Predicate<TPredicate>& predicate) noexcept {
        return NotPredicate<TPredicate>(TPredicate(static_cast<const TPredicate&>(predicate)));
    }
 
    template<typename TPredicate> inline constexpr auto operator!(Predicate<TPredicate>&& predicate) noexcept {
        return NotPredicate<TPredicate>(std::forward<TPredicate>(static_cast<TPredicate&&>(predicate)));
    }
 
    template<typename Callable> [[nodiscard]] inline constexpr auto predicate(Callable&& callable) noexcept {
        return UserPredicate<Callable>(std::forward<Callable>(callable));
    }
 
    template<typename T> [[nodiscard]] inline constexpr auto eq(T value) noexcept {
        return predicate([value = std::forward<T>(value)](const auto& input) constexpr noexcept(noexcept(input == value)) { return input == value; });
    }
 
    template<typename T> [[nodiscard]] inline constexpr auto neq(T value) noexcept {
        return predicate([value = std::forward<T>(value)](const auto& input) constexpr noexcept(noexcept(input != value)) { return input != value; });
    }
 
    template<typename T> [[nodiscard]] inline constexpr auto gt(T value) noexcept {
        return predicate([value = std::forward<T>(value)](const auto& input) constexpr noexcept(noexcept(input > value)) { return input > value; });
    }
 
    template<typename T> [[nodiscard]] inline constexpr auto gte(T value) noexcept {
        return predicate([value = std::forward<T>(value)](const auto& input) constexpr noexcept(noexcept(input >= value)) { return input >= value; });
    }
 
    template<typename T> [[nodiscard]] inline constexpr auto lt(T value) noexcept {
        return predicate([value = std::forward<T>(value)](const auto& input) constexpr noexcept(noexcept(input < value)) { return input < value; });
    }
 
    template<typename T> [[nodiscard]] inline constexpr auto lte(T value) noexcept {
        return predicate([value = std::forward<T>(value)](const auto& input) constexpr noexcept(noexcept(input <= value)) { return input <= value; });
    }
 
} // namespace CeresEngine