cpphibernate/include/cpphibernate/misc/equality_compare.inl

#pragma once

#include "equality_compare.h"

namespace cpphibernate
{

    namespace __impl
    {

        template<typename T_lhs, typename T_rhs, typename = void>
        struct equality_compare_impl
        {
            static constexpr decltype(auto) equal(T_lhs&&, T_rhs&&)
                { static_assert(sizeof(T_lhs) == -1, "Unable to equality compare these two types."); }

            static constexpr decltype(auto) not_equal(T_lhs&&, T_rhs&&)
                { static_assert(sizeof(T_lhs) == -1, "Unable to equality compare these two types."); }
        };

        template<typename T_lhs, typename T_rhs>
        struct equality_compare_impl<
            T_lhs,
            T_rhs,
            mp::enable_if_t<
                    mp::is_valid_v<typename T_lhs::equality_compare_group_type>
                &&  mp::is_valid_v<typename T_rhs::equality_compare_group_type>
                &&  mp::is_same_v<
                        typename T_lhs::equality_compare_group_type,
                        typename T_rhs::equality_compare_group_type>>>
        {
            static constexpr decltype(auto) equal(T_lhs&&, T_rhs&&)
                { return hana::type_c<mp::decay_t<T_lhs>> == hana::type_c<mp::decay_t<T_rhs>>; }

            static constexpr decltype(auto) not_equal(T_lhs&&, T_rhs&&)
                { return hana::type_c<mp::decay_t<T_lhs>> != hana::type_c<mp::decay_t<T_rhs>>; }
        };

    };

    template<typename T_group>
    struct tag_equality_comparable
    {
        using equality_compare_group_type = T_group;
    };

    template<typename T_lhs, typename T_rhs>
    constexpr decltype(auto) operator == (T_lhs&& lhs, T_rhs&& rhs)
    {
        using equality_compare_type = __impl::equality_compare_impl<T_lhs, T_rhs>;
        return equality_compare_type::equal(std::forward<T_lhs>(lhs), std::forward<T_rhs>(rhs));
    }

    template<typename T_lhs, typename T_rhs>
    constexpr decltype(auto) operator != (T_lhs&& lhs, T_rhs&& rhs)
    {
        using equality_compare_type = __impl::equality_compare_impl<T_lhs, T_rhs>;
        return equality_compare_type::not_equal(std::forward<T_lhs>(lhs), std::forward<T_rhs>(rhs));
    }

}